<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 2.5.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.
- Si Edge Microgateway est en cours d'exécution, arrêtez-le maintenant:
edgemicro stop
-
cdvers le répertoire personnalisé du plug-in:cd [prefix]/lib/node_modules/edgemicro/pluginsoù
[prefix]est le répertoire avec préfixenpm. comme décrit dans la section "Où Edge Microgateway est-il installé ?" dans Installation d'Edge Microgateway : - Créez un projet de plug-in nommé response-override et
cd. par exemple:
mkdir response-override && cd response-override
- Créez un projet Node.js:
npm init
- Utilisez un éditeur de texte pour créer un fichier appelé
index.js. - Copiez le code suivant dans
index.jset 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"); } }; }
- 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ùorgetenvsont les noms de votre organisation et de votre environnement Edge. - Ajoutez le plug-in
response-overrideà l'élémentplugins:sequence. comme indiqué ci-dessous.
... plugins: dir: ../plugins sequence: - oauth - response-override ... - Redémarrez Edge Microgateway.
- 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.jsonet unindex.jsdans 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.
onrequestondata_requestonend_requestonclose_requestonerror_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.
onresponseondata_responseonend_responseonclose_responseonerror_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
Objet de configuration obtenu après la fusion du fichier de configuration Edge Microgateway avec
les informations téléchargées à partir d'Apigee Edge, telles que les produits et les quotas. Vous trouverez
configuration spécifique au plug-in dans cet objet: config.<plugin-name>.
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
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)
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_responseest 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.
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); } }; }