Développer des plug-ins personnalisés

<ph type="x-smartling-placeholder"></ph> Vous consultez la documentation Apigee Edge.
Accédez à la page Documentation sur Apigee X. En savoir plus

Edge Microgateway version 3.3.x

Audience

Cet article est destiné aux développeurs qui souhaitent étendre les fonctionnalités d'Edge Microgateway en écrivant des plug-ins personnalisés. Si vous souhaitez écrire un nouveau plug-in, vous devez connaître JavaScript et Node.js obligatoire.

Qu'est-ce qu'un plug-in Edge Microgateway personnalisé ?

Un plug-in est un module Node.js qui ajoute des fonctionnalités à Edge Microgateway. Modules de plug-ins suivent un schéma cohérent et sont stockés dans un emplacement connu d'Edge Microgateway, de les détecter et de les exécuter automatiquement. Plusieurs plug-ins prédéfinis sont fournis installer Edge Microgateway. Il s'agit notamment de plug-ins pour l'authentification, l'arrêt des pics, les quotas et analyse. Ces plug-ins existants sont décrits dans la section Utiliser des plug-ins.

Vous pouvez ajouter de nouvelles fonctionnalités à la micropasserelle en écrivant des valeurs personnalisées plug-ins. Par défaut, Edge Microgateway est essentiellement un proxy passthrough sécurisé qui transmet les requêtes et les réponses inchangées à et depuis les services cibles. Grâce aux plug-ins personnalisés, vous pouvez : de manière programmatique avec les requêtes et les réponses qui transitent par la micropasserelle.

Où placer le code de plug-in personnalisé ?

Un dossier pour les plug-ins personnalisés est inclus dans l'installation d'Edge Microgateway ici:

[prefix]/lib/node_modules/edgemicro/node_modules/microgateway-plugins

où [prefix] est le répertoire avec le préfixe npm décrit dans la section "Où Edge Microgateway est-il installé ?" dans Installation d'Edge Microgateway :

Vous pouvez modifier ce répertoire par défaut du plug-in. Voir Où trouver plug-ins.

Examiner les plug-ins prédéfinis

Avant d'essayer de développer votre propre plug-in, il est bon de vérifier qu'aucun des plug-ins prédéfinis qui répondent à vos besoins. Ces plug-ins se trouvent dans:

[prefix]/lib/node_modules/edgemicro/node_modules/microgateway-plugins

où [prefix] est le répertoire avec préfixe npm. Voir "Où Edge Microgateway est-il installé ?" de la section Installation d'Edge Microgateway :

Pour en savoir plus, consultez également la section Prédéfinis plug-ins fournis avec Edge Microgateway.

Écrire un plug-in simple

Dans cette section, nous allons découvrir la procédure à suivre pour créer un plug-in simple. Ce plug-in remplace les données de réponse (quelles qu'elles soient) par la chaîne "Hello, World!". et l'imprime du terminal.

1. Si Edge Microgateway est en cours d'exécution, arrêtez-le maintenant:
   

   edgemicro stop
   

2. cd vers le répertoire personnalisé du plug-in:

   cd [prefix]/lib/node_modules/edgemicro/plugins

   où [prefix] est le répertoire avec préfixe npm. comme décrit dans la section "Où Edge Microgateway est-il installé ?" dans Installation d'Edge Microgateway :

3. Créez un projet de plug-in nommé response-override et cd. par exemple:
   

   mkdir response-override && cd response-override
   

4. Créez un projet Node.js:
   

   npm init
   

   Appuyez plusieurs fois sur "Retour" pour accepter les valeurs par défaut.
5. Utilisez un éditeur de texte pour créer un fichier appelé index.js.
6. Copiez le code suivant dans index.js et enregistrez le fichier.
   

   'use strict';
   var debug = require('debug')
   
   module.exports.init = function(config, logger, stats) {
   
     return {
      
       ondata_response: function(req, res, data, next) {
         debug('***** plugin ondata_response');
         next(null, null);
       },
       
       onend_response: function(req, res, data, next) {
         debug('***** plugin onend_response');
         next(null, "Hello, World!\n\n");
       }
     };
   }
   

7. Vous avez maintenant créé un plug-in et vous devez l'ajouter à la configuration Edge Microgateway. Ouvrez le fichier $HOME/.edgemicro/[org]-[env]-config.yaml, où org et env sont les noms de votre organisation et de votre environnement Edge.
8. Ajoutez le plug-in response-override à l'élément plugins:sequence. comme indiqué ci-dessous.
   

         ...
         
         plugins:
           dir: ../plugins
           sequence:
             - oauth
             - response-override
             
         ...
   

9. Redémarrez Edge Microgateway.
10. Appeler une API via Edge Microgateway (Cet appel d'API suppose que vous avez configuré la même dans le tutoriel sur la sécurité des clés API, comme décrit dans la section Configurer et configuration d'Edge Microgateway:
    

    curl -H 'x-api-key: uAM4gBSb6YoMvTHfx5lXJizYIpr5Jd' http://localhost:8000/hello/echo
    Hello, World!
    

Anatomie d'un plug-in

L'exemple de plug-in Edge Microgateway suivant illustre le modèle à suivre lorsque développer vos propres plug-ins. Le code source de l'exemple de plug-in présenté dans cette section est le suivant : dans le plugins/header-uppercase/index.js.

• Les plug-ins sont des modules NPM standards avec un package.json et un index.js dans le dossier racine.
• Un plug-in doit exporter une fonction init().
• La fonction init() utilise trois arguments: config, logger et stats. Ces arguments sont décrits dans la section init().
• init() renvoie un objet avec des gestionnaires de fonctions nommés qui sont appelés lorsque certains événements se produisent pendant la durée de vie d'une demande.

Fonctions du gestionnaire d'événements

Un plug-in doit implémenter tout ou partie de ces fonctions de gestionnaire d'événements. La mise en œuvre de ces c'est à vous de décider. N'importe quelle fonction est facultative, et un plug-in classique au moins un sous-ensemble de ces fonctions.

Gestionnaires d'événements de flux de requêtes

Ces fonctions sont appelées sur les événements de demande dans Edge Microgateway.

• onrequest
• ondata_request
• onend_request
• onclose_request
• onerror_request

Fonction onrequest

Appelé au début de la requête client. Cette fonction se déclenche lorsque le premier octet de la est reçue par Edge Microgateway. Cette fonction vous donne accès aux en-têtes de requête, l'URL, les paramètres de requête et la méthode HTTP. Si vous appelez "next" avec un premier argument véridique (par exemple, (Erreur), le traitement de la requête s'arrête et aucune requête cible n'est lancée.

Exemple :

onrequest: function(req, res, next) {
      debug('plugin onrequest');
      req.headers['x-foo-request-start'] = Date.now();
      next();
    }

Fonction ondata_request

Appelé lorsqu'un fragment de données est reçu du client. Transmettre les données des requêtes au prochain dans la séquence de plug-ins. La valeur renvoyée par le dernier plug-in de la séquence est envoyée à la cible. Un cas d'utilisation typique, illustré ci-dessous, consiste à transformer les données d'une requête avant de les envoyer. à la cible.

Exemple :

ondata_request: function(req, res, data, next) {
      debug('plugin ondata_request ' + data.length);
      var transformed = data.toString().toUpperCase();
      next(null, transformed);
    }

Fonction onend_request

Appelé lorsque toutes les données de la requête ont été reçues du client.

Exemple :

onend_request: function(req, res, data, next) {
      debug('plugin onend_request');
      next(null, data);
    }

Fonction onclose_request

Indique que la connexion client a été fermée. Vous pouvez utiliser cette fonction dans les cas où la connexion au client n'est pas fiable. Il est appelé lorsque la connexion de socket au client est fermé.

Exemple :

onclose_request: function(req, res, next) {
      debug('plugin onclose_request');
      next();
    }

Fonction onerror_request

Appelé en cas d'erreur lors de la réception de la requête du client.

Exemple :

onerror_request: function(req, res, err, next) {
      debug('plugin onerror_request ' + err);
      next();
    }

Gestionnaires d'événements de flux de réponse

Ces fonctions sont appelées sur les événements de réponse dans Edge Microgateway.

• onresponse
• ondata_response
• onend_response
• onclose_response
• onerror_response

Fonction onresponse

Appelé au début de la réponse cible. Cette fonction se déclenche lorsque le premier octet de la est reçue par Edge Microgateway. Cette fonction vous donne accès aux en-têtes de réponse et le code d'état.

Exemple :

onresponse: function(req, res, next) {      
    debug('plugin onresponse');     
    res.setHeader('x-foo-response-time', Date.now() - req.headers['x-foo-request-start'])    
    next();    
}

Fonction ondata_response

Appelé lorsqu'un fragment de données est reçu de la cible.

Exemple :

ondata_response: function(req, res, data, next) {
      debug('plugin ondata_response ' + data.length);
      var transformed = data.toString().toUpperCase();
      next(null, transformed);
    }

Fonction onend_response

Appelé lorsque toutes les données de réponse ont été reçues de la cible.

Exemple :

onend_response: function(req, res, data, next) {
      debug('plugin onend_response');
      next(null, data);
    }

Fonction onclose_response

Indique que la connexion cible est fermée. Vous pouvez utiliser cette fonction dans les cas où la connexion cible n'est pas fiable. Il est appelé lorsque la connexion du socket à la cible est fermé.

Exemple :

onclose_response: function(req, res, next) {
      debug('plugin onclose_response');
      next();
    }

Fonction onerror_response

Appelé en cas d'erreur lors de la réception de la réponse cible.

Exemple :

onerror_response: function(req, res, err, next) {
      debug('plugin onerror_response ' + err);
      next();
    }

Ce que vous devez savoir sur le Fonctions du gestionnaire d'événements de plug-in

Les fonctions de gestionnaire d'événements de plug-in sont appelées en réponse à des événements spécifiques qui se produisent Edge Microgateway traite une requête API donnée.

• Chacun des gestionnaires de fonction init() (ondata_request, ondata_response, etc.) doit appeler le rappel next() une fois l'opération terminée. en cours de traitement. Si vous n'appelez pas next(), le traitement s'arrête et la requête se fige.
• Le premier argument de next() est peut-être une erreur qui provoquera une requête en cours de traitement.
• Les gestionnaires ondata_ et onend_ doivent appeler next() avec un deuxième argument contenant les données à transmettre à la cible ou le client. Cet argument peut être nul si le plug-in est en mémoire tampon et qu'il n'a pas assez de données pour transformer en ce moment.
• Notez qu'une seule instance du plug-in est utilisée pour traiter toutes les requêtes et les réponses. Si un plug-in souhaite conserver l'état de chaque requête entre les appels, il peut l'enregistrer dans un ajoutée à l'objet request fourni (req), dont durée de vie correspond à la durée de l'appel d'API.
• Veillez à intercepter toutes les erreurs et à appeler next() avec l'erreur. Le fait de ne pas next() entraîne le blocage de l'appel d'API.
• Veillez à ne pas introduire de fuites de mémoire, car cela peut affecter les performances globales d'Edge et la faire planter en cas de manque de mémoire.
• Veillez à suivre le modèle Node.js en n'effectuant pas de tâches exigeantes en ressources de calcul dans car cela peut nuire aux performances d'Edge Microgateway.

À propos de la fonction init() du plug-in

Cette section décrit les arguments transmis à la fonction init(): config, logger et stats.

config

Les données de configuration obtenues en fusionnant le fichier de configuration Edge Microgateway avec les données téléchargées à partir d'Apigee Edge sont placées dans un objet nommé: config.

Ajouter un paramètre de configuration appelé param avec la valeur foo dans un plug-in appelé response-override, placez-le dans le default.yaml :

response-override:
    param: foo

Vous pouvez ensuite accéder au paramètre dans le code de votre plug-in, comme ceci:

// Called when response data is received
    ondata_response: function(req, res, data, next) {
      debug('***** plugin ondata_response');
      debug('***** plugin ondata_response: config.param: ' + config.param);
      next(null, data);
    },

Dans ce cas, "foo" s'affiche dans la sortie de débogage du plug-in:

Sun, 13 Dec 2015 21:25:08 GMT plugin:response-override ***** plugin ondata_response: config.param: foo

Toi peut accéder à la configuration de micropasserelle fusionnée et télécharger les données Apigee Edge dans le objet enfant config.emgConfigs. Par exemple : vous pouvez accéder à ces données de configuration dans la fonction init comme suit:

module.exports.init = function(config, logger, stats) {
   let emgconfigs = config.emgConfigs;

Vous trouverez ci-dessous un exemple de données contenues dans le fichier emgConfigs:

{
    edgemicro:
    {
        port: 8000,
        max_connections: 1000,
        config_change_poll_interval: 600,
        logging:
        {
            level: 'error',
            dir: '/var/tmp',
            stats_log_interval: 60,
            rotate_interval: 24,
            stack_trace: false
        },
        plugins: { sequence: [Array] },
        global: { org: 'Your Org', env: 'test' }
    },
    headers:
    {
        'x-forwarded-for': true,
        'x-forwarded-host': true,
        'x-request-id': true,
        'x-response-time': true,
        via: true
    },
    proxies:
    [    {
                max_connections: 1000,
                name: 'edgemicro_delayed',
                revision: '1',
                proxy_name: 'default',
                base_path: '/edgemicro_delayed',
                target_name: 'default',
                url: 'https://httpbin.org/delay/10',
                timeout: 0
            }
    ],
    product_to_proxy: { EdgeMicroTestProduct: [ 'edgemicro-auth','edgemicro_delayed',] },
    product_to_scopes: {prod4: [ 'Admin', 'Guest', 'Student' ] },
    product_to_api_resource: { EdgeMicroTestProduct: [ '/*' ] },
    _hash: 0,
    keys: { key: 'Your key', secret: 'Your key ' },
    uid: 'Internally generated uuid',
    targets: []
  }

logger

L'enregistreur système. L'enregistreur actuellement utilisé exporte ces fonctions, où les objets peuvent être une chaîne, une requête HTTP, une réponse HTTP ou une instance Error.

• info(object, message)
• warn(object, message)
• error(object, message)
• trace(object, message)
• debug(object, message)

stats

Objet qui contient le nombre de requêtes, de réponses, d'erreurs et d'autres statistiques agrégées liées aux requêtes et aux réponses circulant via une instance de micropasserelle.

• treqErrors : nombre de requêtes cibles comportant des erreurs.
• treqErrors : nombre de réponses cibles comportant des erreurs.
• statusCodes : un objet contenant le code de réponse.

{
  1: number of target responses with 1xx response codes
  2: number of target responses with 2xx response codes
  3: number of target responses with 3xx response codes
  4: number of target responses with 4xx response codes
  5: number of target responses with 5xx response codes
  }
  

• requests : nombre total de requêtes.
• réponses : nombre total de réponses.
• connections : nombre de connexions cibles actives.

À propos de la fonction next()

Toutes les méthodes de plug-in doivent appeler next() pour poursuivre le traitement de la méthode suivante dans la (sinon le processus du plug-in se bloquera). Dans le cycle de vie de la requête, la première méthode appelée onrequest(). La méthode suivante à appeler est ondata_request(). Toutefois, ondata_request est appelé uniquement si la requête inclut des données, comme dans dans le cas d'une requête POST, par exemple. La prochaine méthode appelée sera onend_request(), qui est appelé une fois le traitement de la requête terminé. La Les fonctions onerror_* ne sont appelées qu'en cas d'erreur. Elles vous permettent de gérez les erreurs avec du code personnalisé, si vous le souhaitez.

Supposons que des données soient envoyées dans la requête et que ondata_request() soit appelé. Avertissement que la fonction appelle next() avec deux paramètres:

next(null, data);

Par convention, le premier paramètre est utilisé pour transmettre des informations sur l'erreur, que vous pouvez ensuite dans une fonction ultérieure de la chaîne. En le définissant sur null, , nous disons qu'il n'y a pas d'erreur et que le traitement des requêtes devrait se dérouler normalement. Si cet argument est vrai (par exemple, un objet Error), alors le traitement de la requête s'arrête et la requête est envoyés à la cible.

Le deuxième paramètre transmet les données de la requête à la fonction suivante dans la chaîne. Si vous ne un traitement supplémentaire, les données de la requête sont transmises telles quelles à la cible de l'API. Vous avez toutefois la possibilité de modifier les données de requête dans cette méthode et de transmettre les valeurs à la cible. Par exemple, si les données de la requête sont au format XML et que la cible attend JSON, vous pouvez alors ajouter du code à la méthode ondata_request() qui (a) modifie la Content-Type de l'en-tête de requête en application/json et convertit les données de la requête au format JSON avec la méthode de votre choix (par exemple, vous pouvez utiliser xml2json obtenu à partir de NPM).

Voyons à quoi cela pourrait ressembler:

ondata_request: function(req, res, data, next) {
  debug('****** plugin ondata_request');
  var translated_data = parser.toJson(data);
  next(null, translated_data);
},

Dans ce cas, les données de la requête (appelées "XML") sont converties au format JSON. les données transformées sont transmises via next() à la fonction suivante dans la chaîne de requête, avant d'être transmises à la cible backend.

Notez que vous pouvez ajouter une autre instruction de débogage pour imprimer les données transformées à des fins de débogage. objectifs. Exemple :

ondata_request: function(req, res, data, next) {
  debug('****** plugin ondata_request');
  var translated_data = parser.toJson(data);
  debug('****** plugin ondata_response: translated_json: ' + translated_json);
  next(null, translated_data);
},

À propos Ordre d'exécution du gestionnaire de plug-ins

Si vous écrivez des plug-ins pour Edge Microgateway, vous devez comprendre l'ordre dans lequel et les gestionnaires d'événements sont exécutés.

Le point important à retenir est que lorsque vous spécifiez une séquence de plug-in dans la périphérie fichier de configuration Microgateway, les gestionnaires de requêtes s'exécutent dans l'ordre croissant, tandis que les gestionnaires de réponses s'exécutent dans l'ordre décroissant.

L'exemple suivant est conçu pour vous aider à comprendre cette séquence d'exécution.

1. Créez trois plug-ins

Prenons l'exemple du plug-in suivant. Il suffit d'imprimer la sortie de la console lorsque ses gestionnaires d'événements sont appelé:

plugins/plugin-1/index.js ;

module.exports.init = function(config, logger, stats) {

  return {

    onrequest: function(req, res, next) {
      console.log('plugin-1: onrequest');
      next();
    },

    onend_request: function(req, res, data, next) {
      console.log('plugin-1: onend_request');
      next(null, data);
    },

    ondata_response: function(req, res, data, next) {
      console.log('plugin-1: ondata_response ' + data.length);
      next(null, data);
    },

    onend_response: function(req, res, data, next) {
      console.log('plugin-1: onend_response');
      next(null, data);
    }
  };
}

Maintenant, envisagez de créer deux autres plug-ins, plugin-2 et plugin-3, avec le même code (sauf en remplaçant les instructions console.log() par plugin-2) et plugin-3 respectivement).

2. Examiner le code du plug-in

Le plug-in exporté fonctionne dans <microgateway-root-dir>/plugins/plugin-1/index.js sont des gestionnaires d'événements qui s'exécuter à des moments spécifiques pendant le traitement des requêtes et des réponses. Par exemple : onrequest exécute le premier octet des en-têtes de requête reçu. Alors que, onend_response s'exécute après la réception du dernier octet des données de réponse.

Examinez le gestionnaire ondata_response. Il est appelé à chaque fois qu'un fragment de données de réponse est reçue. Il est important de savoir que les données de réponse ne sont pas nécessairement reçues une seule fois. Les données peuvent plutôt être reçues par blocs de longueur arbitraire.

3. Ajoutez les plug-ins à la séquence du plug-in

En continuant avec cet exemple, nous allons ajouter les plug-ins à la séquence de plug-ins dans Fichier de configuration Microgateway (~./edgemicro/config.yaml) comme indiqué ci-dessous. La séquence est importantes. Il définit l'ordre d'exécution des gestionnaires de plug-in.

  plugins:
    dir: ../plugins
    sequence:
      - plugin-1
      - plugin-2
      - plugin-3
  

4. Examiner le résultat du débogage

Voyons maintenant le résultat qui serait produit lorsque ces plug-ins sont appelés. Il y a quelques points importants à noter:

• La séquence du plug-in dans le fichier de configuration Edge Microgateway (~./edgemicro/config.yaml) spécifie l'ordre dans lequel les gestionnaires d'événements sont appelé.
• Les gestionnaires de requêtes sont appelés dans l'ordre croissant (ordre dans lequel ils apparaissent dans l'ordre du plug-in (1, 2, 3).
• Les gestionnaires de réponses sont appelés dans l'ordre décroissant : 3, 2, 1.
• Le gestionnaire ondata_response est appelé une fois pour chaque fragment de données que arrive. Dans cet exemple (la sortie illustrée ci-dessous), deux fragments sont reçus.

Voici un exemple de résultat de débogage généré lorsque ces trois plug-ins sont utilisés et qu'une requête est envoyée via Edge Microgateway. Notez simplement l'ordre dans lequel les gestionnaires sont appelés:

  plugin-1: onrequest
  plugin-2: onrequest
  plugin-3: onrequest

  plugin-1: onend_request
  plugin-2: onend_request
  plugin-3: onend_request

  plugin-3: ondata_response 931
  plugin-2: ondata_response 931
  plugin-1: ondata_response 931

  plugin-3: ondata_response 1808
  plugin-3: onend_response

  plugin-2: ondata_response 1808
  plugin-2: onend_response

  plugin-1: ondata_response 1808
  plugin-1: onend_response

Résumé

Il est très important de comprendre l'ordre dans lequel les gestionnaires de plug-ins sont appelés implémenter des fonctionnalités de plug-in personnalisées, telles que l'accumulation et la transformation de requêtes ou de réponses ; données.

N'oubliez pas que les gestionnaires de requêtes sont exécutés dans l'ordre dans lequel les plug-ins sont spécifiés dans le fichier de configuration Edge Microgateway, et les gestionnaires de réponses sont exécutés dans la l'ordre inverse.

À propos de l'utilisation de variables globales dans les plug-ins

Chaque requête envoyée à Edge Microgateway est envoyée à la même instance d'un plug-in. Par conséquent, un l'état de la deuxième requête d'un autre client écrasera la première. Le seul endroit sûr d'enregistrer l'état du plug-in consiste à le stocker dans une propriété de l'objet de requête ou de réponse (dont sa durée de vie est limitée à celle de la requête).

Réécriture des URL cibles dans les plug-ins

Ajoutée dans: v2.3.3

Vous pouvez remplacer l'URL cible par défaut dans un plug-in de manière dynamique en modifiant ces variables dans le code de votre plug-in: req.targetHostname et req.targetPath.

Ajoutée à: v2.4.x

Vous pouvez également ignorer le port du point de terminaison cible et choisir entre HTTP et HTTPS. Modifier ces dans le code de votre plug-in: req.targetPort et req.targetSecure. Pour choisir HTTPS, définissez req.targetSecure sur true; Pour HTTP, définissez-le sur false. Si vous définissez req.targetSecure sur true, consultez cette discussion fil de discussion pour en savoir plus.

Supprimé dans la version 3.3.3

L'exemple de plug-in nommé eurekaclient a été supprimé d'Edge Microgateway dans version 3.3.3. Consultez les notes de version.

La suppression de cette fonctionnalité n'affecte pas le fonctionnement de base de Edge microgateway ou la réécriture des URL cibles. Vous pouvez configurer la recherche et le remplacement dynamiques des points de terminaison des variables cibles telles que req.targetHostname, req.targetPath, req.targetPort et req.targetSecure au niveau du plug-in. Consultez la section Réécrire les URL cibles dans les plug-ins.

Exemples de plug-ins

Ces plug-ins sont fournis avec votre installation Edge Microgateway. Vous les trouverez dans la Installation d'Edge Microgateway ici:

[prefix]/lib/node_modules/edgemicro/plugins

où [prefix] est le répertoire avec le préfixe npm décrit dans la section "Où Edge Microgateway est-il installé ?" dans Installation d'Edge Microgateway :

accumulate-request

Ce plug-in accumule des fragments de données du client dans une propriété de tableau associée au . Lorsque toutes les données de requête sont reçues, le tableau est concaténé dans un tampon qui est ensuite transmise au plug-in suivant dans la séquence. Ce plug-in doit être le premier plug-in de la séquence afin que les plug-ins suivants reçoivent les données de requête accumulées.

module.exports.init = function(config, logger, stats) {

  function accumulate(req, data) {

    if (!req._chunks) req._chunks = [];
    req._chunks.push(data);

  }

  return {

    ondata_request: function(req, res, data, next) {

      if (data && data.length > 0) accumulate(req, data);

      next(null, null);

    },


    onend_request: function(req, res, data, next) {

      if (data && data.length > 0) accumulate(req, data);

      var content = null;

      if (req._chunks && req._chunks.length) {

        content = Buffer.concat(req._chunks);

      }

      delete req._chunks;

      next(null, content);

    }

  };

}

accumulate-response

Ce plug-in accumule des fragments de données de la cible dans une propriété de tableau associée au . Lorsque toutes les données de réponse sont reçues, le tableau est concaténé dans un tampon qui est ensuite transmise au plug-in suivant dans la séquence. Comme ce plug-in fonctionne d'entrée, qui sont traitées dans l'ordre inverse, placez-le en tant que dernier plug-in de la séquence.

module.exports.init = function(config, logger, stats) {

  function accumulate(res, data) {
    if (!res._chunks) res._chunks = [];
    res._chunks.push(data);
  }

  return {

    ondata_response: function(req, res, data, next) {
      if (data && data.length > 0) accumulate(res, data);
      next(null, null);
    },

    onend_response: function(req, res, data, next) {
      if (data && data.length > 0) accumulate(res, data);
      var content = Buffer.concat(res._chunks);
      delete res._chunks;
      next(null, content);
    }

  };

}

Plug-in header-uppercase

Les distributions Edge Microgateway incluent un exemple de plug-in appelé <microgateway-root-dir>/plugins/header-uppercase L'exemple comprend des commentaires décrivant chacun des gestionnaires de fonctions. Cet exemple effectue une transformation simple des données la réponse cible et ajoute des en-têtes personnalisés à la requête du client et à la réponse cible.

Voici le code source de <microgateway-root-dir>/plugins/header-uppercase/index.js:

'use strict';

var debug = require('debug')('plugin:header-uppercase');

// required
module.exports.init = function(config, logger, stats) {

  var counter = 0;

  return {

    // indicates start of client request
    // request headers, url, query params, method should be available at this time
    // request processing stops (and a target request is not initiated) if
    // next is called with a truthy first argument (an instance of Error, for example)
    onrequest: function(req, res, next) {
      debug('plugin onrequest');
      req.headers['x-foo-request-id'] = counter++;
      req.headers['x-foo-request-start'] = Date.now();
      next();
    },

    // indicates start of target response
    // response headers and status code should be available at this time
    onresponse: function(req, res, next) {
      debug('plugin onresponse');
      res.setHeader('x-foo-response-id', req.headers['x-foo-request-id']);
      res.setHeader('x-foo-response-time', Date.now() - req.headers['x-foo-request-start']);
      next();
    },

    // chunk of request body data received from client
    // should return (potentially) transformed data for next plugin in chain
    // the returned value from the last plugin in the chain is written to the target
    ondata_request: function(req, res, data, next) {
      debug('plugin ondata_request ' + data.length);
      var transformed = data.toString().toUpperCase();
      next(null, transformed);
    },

    // chunk of response body data received from target
    // should return (potentially) transformed data for next plugin in chain
    // the returned value from the last plugin in the chain is written to the client
    ondata_response: function(req, res, data, next) {
      debug('plugin ondata_response ' + data.length);
      var transformed = data.toString().toUpperCase();
      next(null, transformed);
    },

    // indicates end of client request
    onend_request: function(req, res, data, next) {
      debug('plugin onend_request');
      next(null, data);
    },

    // indicates end of target response
    onend_response: function(req, res, data, next) {
      debug('plugin onend_response');
      next(null, data);
    },

    // error receiving client request
    onerror_request: function(req, res, err, next) {
      debug('plugin onerror_request ' + err);
      next();
    },

    // error receiving target response
    onerror_response: function(req, res, err, next) {
      debug('plugin onerror_response ' + err);
      next();
    },

    // indicates client connection closed
    onclose_request: function(req, res, next) {
      debug('plugin onclose_request');
      next();
    },

    // indicates target connection closed
    onclose_response: function(req, res, next) {
      debug('plugin onclose_response');
      next();
    }

  };

}

transformation en majuscules

Il s'agit d'un plug-in de transformation général que vous pouvez modifier pour faire la transformation souhaitée. Cet exemple transforme simplement la réponse et les données de requête en majuscules.

 */
module.exports.init = function(config, logger, stats) {

  // perform content transformation here
  // the result of the transformation must be another Buffer
  function transform(data) {
    return new Buffer(data.toString().toUpperCase());
  }

  return {

    ondata_response: function(req, res, data, next) {
      // transform each chunk as it is received
      next(null, data ? transform(data) : null);
    },

    onend_response: function(req, res, data, next) {
      // transform accumulated data, if any
      next(null, data ? transform(data) : null);
    },

    ondata_request: function(req, res, data, next) {
      // transform each chunk as it is received
      next(null, data ? transform(data) : null);
    },

    onend_request: function(req, res, data, next) {
      // transform accumulated data, if any
      next(null, data ? transform(data) : null);
    }

  };

}