Puppeteer / Node - Target.createTarget - Cible fermée

Question

Je suis en train d'utiliser Node/Puppeteer dans le code ci-dessous, en passant une grande liste d'URL pour le parcours et le scraping. Il a été difficile de le faire de manière asynchrone, bien que je trouve que je me rapproche de plus en plus de la réponse. Je suis actuellement bloqué sur un problème lié à l'erreur suivante.

UnhandledPromiseRejectionWarning: Rejet de la promesse non géré (identifiant du rejet : 17): Erreur : Erreur de protocole (Target.createTarget) : Cible fermée.

Cette erreur se produit une fois à chaque itération de la boucle while. Bien que je ne sois pas sûr de ce que je pourrais faire de manière incorrecte.

Est-ce que quelqu'un pourrait m'aider à faire ce qui suit :
1) Diagnostiquer la source de l'erreur.
2) Trouver éventuellement un moyen plus efficace de parcourir une grande liste d'URL de manière asynchrone.

async function subProc(list, batchSize) {
let subList = null;
let i = 0;

while (list.length > 0) {
    let browser = await puppeteer.launch();
    subList = list.splice(0, batchSize);
    console.log("Taille de la liste principale :: " + list.length);
    console.log("Taille de la sous-liste :: " + subList.length);

    for (let j = 0; j < subList.length; j++) {
        promiseArray.push(new Promise((resolve, reject) => {
            resolve(pageScrape(subList[j], browser));
        }));
    }
    Promise.all(promiseArray)
        .then(response => {
            procArray.concat(response);
        });
    promiseArray = new Array();
    try {
        await browser.close();
    } catch(ex){
        console.log(ex);
    }
};
}

async function pageScrape(url, browser) {
let page = await browser.newPage();
await page.goto(url, {
    timeout: 0
});
await page.waitFor(1000);
return await page.evaluate(() => {
    let appTitle = document.querySelector('').innerText;
    let companyName = document.querySelector('').innerText;
    let dateListed = document.evaluate("", document, null, XPathResult.FIRST_ORDERED_NODE_TYPE, null).singleNodeValue.innerText;
    let category = document.evaluate("']//a//strong", document, null, XPathResult.FIRST_ORDERED_NODE_TYPE, null).singleNodeValue.innerText;
    /*  */
    return {
        appTitle,
        companyName,
        dateListed,
        category
    }
}).then(response => {
    let urlData = {
        id: subList[j],
        appName: response.appTitle,
        companyName: response.companyName,
        dateListed: response.dateListed,
        category: response.category
    }
    return urlData;
});

};

Answer 1

J'ai trouvé la solution au problème que je rencontrais. Chaque ordinateur a une capacité de traitement limitée, donc au lieu de parcourir 1000 URL simultanément, vous devez le diviser en morceaux plus petits.

En utilisant un Promise.all, en itérant et en extrayant 10 URLs à la fois et en stockant ces valeurs dans un tableau, j'ai pu limiter le traitement nécessaire pour parcourir toutes les 1000 URLs.

 processBatch(sousDonnées, 10, tableauProc).then((traité)=>{
            for(let i = 0; i < tableauProc.length; i++){
                for(let j = 0; j < tableauProc[i].length; j++){
                   résultats.push(tableauProc[i][j]);
                }
            }

 function processBatch(listePrincipale, tailleLot, tableauProc){
    return Promise.all(listePrincipale.splice(0, tailleLot).map(async url => 
    {
    return singleScrape(url)
    })).then((résultats) => {
    if (listePrincipale.length < tailleLot) {
        console.log('terminé');
        tableauProc.push(résultats);
        return tableauProc;
    } else {
        console.log('Taille de la liste principale :: ' + listePrincipale.length);
        tableauProc.push(résultats);
        return processBatch(listePrincipale, tailleLot, tableauProc);
    }
   })
 }