Méthodes des hooks

Ces méthodes fonctionnent sur le principe des hooks. L'implémentation de ces méthodes permet de contrôler le fonctionnement du scraper à différentes étapes, de l'initialisation à la destruction de l'objet.

L'implémentation de toutes les méthodes, à l'exception de parse, est optionnelle.

async parse(set, results)

La méthode parse implémente la logique principale de traitement de la requête et d'obtention du résultat de la collecte de données, les arguments transmis sont :

• set - objet contenant les informations sur la requête :
  • set.query - chaîne de texte de la requête
  • set.lvl - niveau de la requête, par défaut 0
• results - objet contenant les résultats, qui doit être rempli et retourné par la méthode parse()
  • le scraper doit vérifier la présence de chaque clé dans l'objet results et ne la remplir que si elle est présente, optimisant ainsi la vitesse et ne collectant que les données utilisées dans la formation du résultat
  • results contient les clés des variables flat nécessaires avec la valeur none, ce qui signifie par défaut que le résultat n'a pas été obtenu, ainsi que les clés des variables-tableaux (arrays) avec une valeur sous forme de tableau vide, prêt à être rempli
  • results.success doit être défini sur 1 en cas de traitement réussi de la requête, la valeur par défaut est 0, ce qui signifie que la requête a été traitée avec une erreur

Voyons cela sur un exemple :

class JS_HTML_Tags extends BaseParser {
    static defaultConf = {
        results: {
            flat: [
                ['title', 'Title'],
            ],
            arrays: {
                h2: ['H2 Headers List', [
                    ['header', 'Header'],
                ]],
            }
        },
        ...
    };

    async parse(set, results) {
        // Obtention du contenu de la page HTML dont l'adresse a été transmise dans la requête
        const {success, data, headers} = await this.request('GET', set.query);
    
        // Vérification du succès et du type de data, lors d'un traitement correct des pages HTML nous devrions recevoir le type 'string', sinon A-Parser retourne un objet de type Buffer
        if (success && typeof data == 'string') {
            let matches;
            
            // Vérification de la nécessité de collecter le title et sauvegarde de la valeur
            if (results.title && matches = data.match(/<title[^>]*>(.*?)<\/title>/))
                results.title = matches[1];

            // Vérification de la nécessité de collecter h2
            if (results.h2) {
                let count = 0;
                const re = /<h2[^>]*>(.*?)<\/h2>/g;
                while(matches = re.exec(data)) {
                    // Sauvegarde dans une boucle de toutes les balises h2 trouvées
                    results.h2.push(matches[1]);
                }
            }

            // Notification du succès de la collecte de données
            results.success = 1;
        }

        // Retour des résultats traités
        return results;
    }
};

Notez que vous pouvez créer vos propres fonctions et méthodes pour une meilleure organisation du code :

function Answer() {
    return 42;
}

class JS_HTML_Tags extends BaseParser {
    ...

    async parse(set, results) {
        results = await this.doWork(set, results);
        return results;
    }

    async doWork(set, results) {
        results.answer = Answer();
        return results;
    }
};

async processConf?(conf)

Cette méthode est utilisée pour transformer la configuration selon certaines règles, par exemple lors de l'utilisation d'un captcha, nous devons toujours utiliser des sessions :

async processConf(conf) {
    if (conf.useCaptcha)
        conf.useSessions = 1
}

async parse(set, results) {
    if (conf.useSessions)
        await this.login();
}

L'existence de cette méthode est due au fait qu'A-Parser prend en charge les champs de configuration dynamiques et, au sein d'une même tâche, la configuration peut avoir différentes valeurs, ce scénario est possible dans deux cas :

• Utilisation de gabarits dans les champs de configuration, par exemple [% tools.ua.random() %] pour le champ User-Agent
• Utilisation d'overrides lors de l'appel d'un scraper depuis un autre pour this.parser.request

La méthode processConf est appelée une seule fois avant init(). Pour les cas décrits ci-dessus, processConf est appelée en plus avant le traitement de chaque requête

Règles principales d'application de processConf :

• Utilisez-la uniquement si les transformations de la configuration ont un effet sur la performance
• Gardez à l'esprit qu'init est exécuté une seule fois, alors que processConf peut être exécuté pour chaque requête, dans ce cas la logique peut être rompue si init dépend de champs de configuration changeants (voir ci-dessous)

async init?()

La méthode init est appelée une fois lors de l'initialisation de l'objet de base du scraper, elle sert à effectuer des actions uniques :

• Lancement du navigateur
• Initialisation du gestionnaire de sessions à l'aide de la méthode this.sessionManager.init()
• Connexion à la base de données et création de tables dans la BD
• Lecture de données statiques
• Etc.

avertissement

Puisque la méthode est appelée une seule fois, tous les champs de configuration dont dépend init() ne peuvent pas être utilisés conjointement avec des gabarits de champs de configuration ou avec des overrides lors de l'appel de this.parsers.request

async destroy?()

La méthode destroy est appelée une fois à la fin du travail de la tâche, elle est nécessaire pour la destruction correcte des ressources ouvertes :

• Fermeture du navigateur
• Fermeture de la connexion à la BD
• Etc.

async threadInit?()

Cette méthode est lancée lors de l'initialisation de chaque thread, chaque thread est une copie de l'objet de base du scraper avec son propre this.threadId unique, qui commence à 0 et se termine à threads_count - 1

Principales options d'utilisation :

• création d'une page (onglet) de navigateur pour chaque thread

async threadDestroy?()

S'exécute à la fin du thread lors du processus de finalisation de la tâche, sert à libérer les ressources allouées pour ce thread

async afterResultsProcessor?(results)

Cette méthode est exécutée après le traitement des résultats par le constructeur de résultats, le filtrage et la déduplication. Le cas d'utilisation principal est l'ajout de requêtes à la file des tâches à l'aide de la méthode this.query.add après l'application des filtres utilisateur ; c'est ainsi qu'est implémenté le filtrage des liens à suivre (followlinks) pour le scraper HTML::LinkExtractor