Sviluppa plug-in personalizzati

Stai visualizzando la documentazione di Apigee Edge.
Vai alla sezione Documentazione di Apigee X. Informazioni

Edge Microgateway versione 3.3.x

Pubblico

Questo argomento è rivolto agli sviluppatori che vogliono estendere le funzionalità di Edge Microgateway scrivendo personalizzati. Se desideri scrivere un nuovo plug-in, devi poter utilizzare JavaScript e Node.js obbligatorio.

Cos'è un plug-in Edge Microgateway personalizzato?

Un plug-in è un modulo Node.js che aggiunge funzionalità a Edge Microgateway. Moduli plug-in seguono un pattern coerente e vengono archiviati in una posizione nota a Edge Microgateway, consentendo in modo che vengano rilevati ed eseguiti automaticamente. Quando installare Edge Microgateway. tra cui plug-in per l'autenticazione, l'arresto dei picchi, la quota Analytics. Questi plug-in esistenti sono descritti nella sezione Utilizzare i plug-in.

È possibile aggiungere nuove caratteristiche e capacità al microgateway scrivendo dati o plug-in. Per impostazione predefinita, Edge Microgateway è essenzialmente un proxy pass-through sicuro che passa richieste e risposte invariate da e verso i servizi di destinazione. Con i plug-in personalizzati, puoi interagire in modo programmatico con le richieste e le risposte che fluiscono attraverso il microgateway.

Dove inserire il codice del plug-in personalizzato

Nell'installazione di Edge Microgateway è inclusa una cartella per i plug-in personalizzati qui:

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

dove [prefix] è la directory del prefisso npm come descritto in "Dove è installato Edge Microgateway" in Installazione di Edge Microgateway.

Puoi modificare la directory predefinita dei plug-in. Consulta Dove trovare o plug-in.

Controllo dei plug-in predefiniti

Prima di provare a sviluppare un plug-in personalizzato, è bene verificare che nessuno dei plug-in predefiniti i plug-in soddisfano le tue esigenze. Questi plug-in si trovano in:

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

dove [prefix] è la directory del prefisso npm. Consulta anche "Dove è installato Edge Microgateway" in Installazione di Edge Microgateway.

Per maggiori dettagli, vedi anche Predefinito plug-in forniti con Edge Microgateway.

Scrivi un plug-in semplice

In questa sezione, esamineremo i passaggi necessari per creare un plug-in semplice. Questo plug-in sostituisce i dati di risposta (qualunque siano) con la stringa "Hello, World!". e la stampa o nel terminale.

1. Se Edge Microgateway è in esecuzione, interrompilo ora:
   

   edgemicro stop
   

2. cd alla directory dei plug-in personalizzati:

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

   dove [prefix] è la directory del prefisso npm come descritto in "Dove è installato Edge Microgateway" in Installazione di Edge Microgateway.

3. Crea un nuovo progetto plug-in denominato response-override e cd a questo indirizzo:
   

   mkdir response-override && cd response-override
   

4. Crea un nuovo progetto Node.js:
   

   npm init
   

   Premi Invio più volte per accettare i valori predefiniti.
5. Utilizza un editor di testo per creare un nuovo file denominato index.js.
6. Copia il seguente codice in index.js e salva il file.
   

   '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. Ora che hai creato un plug-in, devi aggiungerlo alla configurazione di Edge Microgateway. Apri il file $HOME/.edgemicro/[org]-[env]-config.yaml, dove org e env sono i nomi dell'organizzazione e dell'ambiente Edge.
8. Aggiungi il plug-in response-override all'elemento plugins:sequence come mostrato di seguito.
   

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

9. Riavvia Edge Microgateway.
10. Chiama un'API tramite Edge Microgateway. Questa chiamata API presuppone che tu abbia configurato lo stesso configurazione come tutorial sulla sicurezza delle chiavi API, come descritto in Configurare e configurazione di Edge Microgateway:
    

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

Struttura di un plug-in

Il seguente plug-in di esempio Edge Microgateway illustra il pattern da seguire quando sviluppare plug-in personalizzati. Il codice sorgente per il plug-in di esempio descritto in questa sezione è in plugins/header-uppercase/index.js.

• I plug-in sono moduli di Gestione dei partner di rete standard con package.json e index.js nella cartella principale.
• Un plug-in deve esportare una funzione init().
• La funzione init() accetta tre argomenti: config, logger e stats. Questi argomenti sono descritti nella sezione Plug-in argomenti della funzione init().
• init() restituisce un oggetto con gestori di funzioni denominati che vengono chiamati quando si verificano durante l'intero ciclo di vita di una richiesta.

Funzioni di gestore di eventi

Un plug-in deve implementare alcune o tutte queste funzioni di gestore di eventi. Implementazione di questi dipende da te. Ogni funzione è facoltativa e un plug-in tipico viene implementato in un sottoinsieme di queste funzioni.

Gestori di eventi di flusso di richiesta

Queste funzioni vengono chiamate su eventi di richiesta in Edge Microgateway.

• onrequest
• ondata_request
• onend_request
• onclose_request
• onerror_request

onrequest funzione

Viene chiamato all'inizio della richiesta del client. Questa funzione viene attivata quando il primo byte una richiesta ricevuta da Edge Microgateway. Questa funzione ti dà accesso alle intestazioni delle richieste, URL, parametri di query e metodo HTTP. Se chiami il successivo con un primo argomento veritiero (come di errore), la richiesta di elaborazione si interrompe e la richiesta del target non viene avviata.

Esempio:

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

ondata_request funzione

Richiamato quando un blocco di dati viene ricevuto dal client. Trasmette i dati delle richieste alla successiva nella sequenza di plug-in. Il valore restituito dall'ultimo plug-in della sequenza viene inviato a l'obiettivo. Un caso d'uso tipico, mostrato di seguito, è trasformare i dati della richiesta prima di inviarli all'obiettivo.

Esempio:

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

onend_request funzione

Richiamato quando tutti i dati della richiesta sono stati ricevuti dal client.

Esempio:

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

Funzione onclose_request

Indica che la connessione client è stata chiusa. Puoi usare questa funzione nei casi in cui della connessione al client è inaffidabile. Viene chiamato quando la connessione socket al client chiuso.

Esempio:

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

Funzione onerror_request

Richiamato se si verifica un errore durante la ricezione della richiesta del client.

Esempio:

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

Gestori di eventi del flusso di risposta

Queste funzioni vengono richiamate sugli eventi di risposta in Edge Microgateway.

• onresponse
• ondata_response
• onend_response
• onclose_response
• onerror_response

Funzione onresponse

Viene chiamato all'inizio della risposta target. Questa funzione viene attivata quando il primo byte viene ricevuta da Edge Microgateway. Questa funzione ti dà accesso alle intestazioni delle risposte e codice di stato.

Esempio:

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

Funzione ondata_response

Richiamato quando un blocco di dati viene ricevuto dal target.

Esempio:

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

Funzione onend_response

Richiamato quando tutti i dati della risposta sono stati ricevuti dal target.

Esempio:

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

Funzione onclose_response

Indica che la connessione di destinazione è stata chiusa. Puoi usare questa funzione nei casi in cui connessione di destinazione non è affidabile. Viene chiamato quando la connessione socket alla destinazione chiuso.

Esempio:

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

Funzione onerror_response

Richiamato se si verifica un errore durante la ricezione della risposta target.

Esempio:

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

Ciò che devi sapere Funzioni di gestore di eventi plug-in

Le funzioni di gestione degli eventi del plug-in vengono chiamate in risposta a eventi specifici che si verificano Edge Microgateway elabora una determinata richiesta API.

• Ciascun gestore di funzioni init() (ondata_request, ondata_response e così via) deve chiamare il callback next() al termine dell'operazione e l'elaborazione dei dati. Se non chiami next(), l'elaborazione verrà interrotta e la richiesta si blocca.
• Il primo argomento di next() potrebbe essere un errore che causerà in fase di elaborazione.
• I gestori ondata_ e onend_ devono chiamare next() con un secondo argomento contenente i dati da passare alla destinazione o il cliente. Questo argomento può essere nullo se il plug-in esegue il buffering e non dispone di dati sufficienti per trasformerai al momento.
• Tieni presente che viene utilizzata un'unica istanza del plug-in per tutte le richieste e le risposte. Se un plug-in vuole mantenere lo stato per richiesta tra una chiamata e l'altra, può salvarlo in aggiunta all'oggetto request fornito (req), la cui proprietà è la durata della chiamata API.
• Fai attenzione a individuare tutti gli errori e richiama next() con l'errore. Errore la chiamata a next() provocherà la sospensione della chiamata API.
• Fai attenzione a non introdurre perdite di memoria perché possono influire sulle prestazioni generali di Edge il microgateway e causa l'arresto anomalo se esaurisce la memoria.
• Fai attenzione a seguire il modello Node.js non eseguendo attività ad alta intensità di calcolo nell'interfaccia poiché ciò può influire negativamente sulle prestazioni di Edge Microgateway.

Informazioni sulla funzione init() del plug-in

Questa sezione descrive gli argomenti passati alla funzione init(): config, logger e stats.

config

Dati di configurazione ottenuti unendo il file di configurazione di Edge Microgateway con i dati scaricati da Apigee Edge vengono inseriti in un oggetto denominato config.

Per aggiungere un parametro di configurazione chiamato param con valore foo su un plug-in chiamato response-override, inseriscilo nella sezione default.yaml file:

response-override:
    param: foo

A questo punto, puoi accedere al parametro nel codice del plug-in, in questo modo:

// 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);
    },

In questo caso, nell'output di debug del plug-in verrà visualizzato foo:

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

Tu possono accedere alla configurazione del microgateway unita e scaricare i dati di Apigee Edge nel oggetto secondario config.emgConfigs. Ad esempio: puoi accedere a questi dati di configurazione nella funzione init come segue:

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

Di seguito è riportato un esempio di dati contenuti in 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: []
  }

registratore

Il logger di sistema. Il logger attualmente utilizzato esporta queste funzioni, dove è possibile una stringa, una richiesta HTTP, una risposta HTTP o un'istanza di errore.

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

stats

Un oggetto contenente i conteggi di richieste, risposte, errori e altre statistiche aggregate relative alle richieste e alle risposte che passano attraverso un'istanza microgateway.

• treqErrors - Il numero di richieste di destinazione con errori.
• treqErrors - Il numero di risposte target con errori.
• statusCodes - Un oggetto contenente i conteggi dei codici di risposta:

{
  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
  }
  

• richieste - Il numero totale di richieste.
• responses - Il numero totale di risposte.
• connections - Il numero di connessioni di destinazione attive.

Informazioni sulla funzione next()

Tutti i metodi di plug-in devono chiamare next() per continuare a elaborare il metodo successivo nella (o il processo del plug-in si bloccherà). Nel ciclo di vita della richiesta, il primo metodo chiamato onrequest(). Il prossimo metodo da chiamare è il metodo ondata_request(); ma ondata_request viene chiamato solo se la richiesta include dati, ad esempio nel caso, ad esempio, di una richiesta POST. Il metodo successivo sarà onend_request(), che viene chiamato al completamento dell'elaborazione della richiesta. La Le funzioni onerror_* vengono chiamate solo in caso di errore e ti consentono di gestire gli errori con codice personalizzato, se vuoi.

Supponiamo che i dati vengano inviati nella richiesta e che venga chiamata ondata_request(). Avvisi che la funzione chiama next() con due parametri:

next(null, data);

Per convenzione, il primo parametro viene utilizzato per trasmettere informazioni sull'errore, che possono quindi essere da gestire in una funzione successiva della catena. Se lo imposti su null, viene creata una significa che non sono presenti errori e che l'elaborazione delle richieste dovrebbe procedere normalmente. Se questo argomento è veritiero (come un oggetto Errore), allora l'elaborazione della richiesta si interrompe e la richiesta inviati alla destinazione.

Il secondo parametro passa i dati della richiesta alla funzione successiva nella catena. In caso contrario un'ulteriore elaborazione, i dati della richiesta vengono passati senza modifiche al target dell'API. Tuttavia, hai la possibilità di modificare i dati della richiesta all'interno di questo metodo e trasmettere le una richiesta per il target. Ad esempio, se i dati della richiesta sono in formato XML e la destinazione prevede JSON, puoi aggiungere codice al metodo ondata_request() che (a) modifica Content-Type dell'intestazione della richiesta in application/json e converte i dati della richiesta in JSON utilizzando qualsiasi mezzo desiderato (ad esempio, potresti usare un file Node.js convertitore xml2json ottenuto da Gestione dei partner di rete).

Vediamo che aspetto potrebbe:

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

In questo caso, i dati della richiesta (che si presume siano XML) vengono convertiti in JSON e i dati trasformati vengono passati tramite next() alla funzione successiva nella catena di richieste, prima di essere passati alla destinazione del backend.

Tieni presente che potresti aggiungere un'altra istruzione di debug per stampare i dati trasformati per il debug scopi. Ad esempio:

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);
},

Informazioni ordine di esecuzione gestore plug-in

Se scrivi plug-in per Edge Microgateway, devi capire l'ordine di inserimento dei plug-in e gestire i gestori di eventi.

Il punto importante da ricordare è che, quando specifichi una sequenza di plug-in in il file di configurazione del microgateway, i gestori delle richieste vengono eseguiti in ordine crescente mentre i gestori delle risposte vengono eseguiti in ordine decrescente.

L'esempio seguente è progettato per aiutarti a comprendere questa sequenza di esecuzione.

1. Crea tre semplici plug-in

Prendi in considerazione il seguente plug-in. Esegue solo la stampa dell'output della console quando i relativi gestori di eventi chiamato:

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);
    }
  };
}

Ora valuta la possibilità di creare altri due plug-in, plugin-2 e plugin-3, con lo stesso codice (tranne la modifica delle istruzioni console.log() in plugin-2 e plugin-3 rispettivamente).

2. Esamina il codice del plug-in

Il plug-in esportato funziona in <microgateway-root-dir>/plugins/plugin-1/index.js sono gestori di eventi che vengono eseguiti in momenti specifici durante l'elaborazione della richiesta e della risposta. Ad esempio: onrequest esegue il primo byte delle intestazioni della richiesta ricevute. Mentre, onend_response viene eseguito dopo la ricezione dell'ultimo byte di dati di risposta.

Dai un'occhiata al gestore ondata_response: viene chiamato ogni volta che un blocco di dati di risposta quando riceve il messaggio di errore. La cosa importante da sapere è che i dati delle risposte non vengono necessariamente ricevuti tutti una volta sola. Piuttosto, i dati possono essere ricevuti in blocchi di lunghezza arbitraria.

3. Aggiungi i plug-in a la sequenza di plug-in

Continuando con questo esempio, aggiungeremo i plug-in alla sequenza di plug-in in Edge File di configurazione del microgateway (~./edgemicro/config.yaml) come segue. La sequenza è importanti. Definisce l'ordine di esecuzione dei gestori dei plug-in.

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

4. Esaminare l'output di debug

Ora diamo un'occhiata all'output che verrebbe prodotto quando vengono chiamati questi plug-in. Esistono alcuni punti importanti da notare:

• La sequenza del plug-in del file di configurazione di Edge Microgateway (~./edgemicro/config.yaml) specifica l'ordine in cui vengono visualizzati i gestori di eventi chiamato.
• I gestori delle richieste vengono chiamati in ordine crescente (l'ordine in cui vengono visualizzate nella sequenza di plug-in -- 1, 2, 3).
• I gestori delle risposte vengono chiamati in ordine decrescente: 3, 2, 1.
• Il gestore ondata_response viene chiamato una volta per ogni blocco di dati in arrivo. In questo esempio (output mostrato di seguito), vengono ricevuti due blocchi.

Ecco un esempio di output di debug generato quando questi tre plug-in sono in uso e viene inviata una richiesta attraverso Edge Microgateway. Osserva l'ordine in cui vengono chiamati i gestori:

  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

Riepilogo

Comprendere l'ordine di chiamata dei gestori dei plug-in è molto importante quando Implementare funzionalità plug-in personalizzate, come l'accumulo e la trasformazione di richieste o risposte e i dati di Google Cloud.

Ricorda che i gestori delle richieste vengono eseguiti nell'ordine in cui i plug-in vengono specificato nel file di configurazione di Edge Microgateway, e i gestori di risposte vengono eseguiti nel in ordine opposto.

Informazioni sull'utilizzo delle variabili globali nei plug-in

Ogni richiesta a Edge Microgateway viene inviata alla stessa istanza di un plug-in; pertanto, lo stato della seconda richiesta da un altro client sovrascriverà la prima. L'unico posto sicuro in cui salva lo stato del plug-in memorizzando lo stato in una proprietà dell'oggetto richiesta o risposta (il cui è limitata a quella della richiesta).

Riscrittura degli URL di destinazione nei plug-in

Aggiunto in: versione 2.3.3

Puoi sostituire l'URL di destinazione predefinito in un plug-in in modo dinamico modificando queste variabili nel codice del plug-in: req.targetHostname e req.targetPath.

Aggiunto in: versione 2.4.x

Puoi anche eseguire l'override della porta dell'endpoint di destinazione e scegliere tra HTTP e HTTPS. Modifica questi variabili nel codice del plug-in: req.targetPort e req.targetSecure. Per scegliere HTTPS, imposta req.targetSecure su true; per HTTP, impostalo su false. Se imposti req.targetSecure su true, consulta questa discussione thread per ulteriori informazioni.

Rimosso in: v3.3.3

Il plug-in di esempio denominato eurekaclient è stato rimosso da Edge Microgateway in v.3.3.3. Vedi le Note di rilascio.

La rimozione di questa funzionalità non influisce sulla funzionalità di base del microgateway Edge o la riscrittura degli URL di destinazione. Puoi configurare la ricerca e l'override degli endpoint dinamici variabili target come req.targetHostname, req.targetPath, req.targetPort e req.targetSecure alle a livello di plug-in. Consulta Riscrittura degli URL di destinazione nei plug-in.

Plug-in di esempio

Questi plug-in vengono forniti con l'installazione di Edge Microgateway. Puoi trovarli nella Installazione di Edge Microgateway qui:

[prefix]/lib/node_modules/edgemicro/plugins

dove [prefix] è la directory del prefisso npm come descritto in "Dove è installato Edge Microgateway" in Installazione di Edge Microgateway.

accumulate-request

Questo plug-in accumula blocchi di dati dal client in una proprietà array collegata al di richiesta di addestramento. Quando tutti i dati della richiesta sono ricevuti, l'array viene concatenato in un che viene poi passato al plug-in successivo nella sequenza. Questo plug-in dovrebbe essere il primo plug-in nella sequenza, in modo che i plug-in successivi ricevano i dati delle richieste accumulati.

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

Questo plug-in accumula blocchi di dati dalla destinazione in una proprietà array collegata al . Quando tutti i dati di risposta sono ricevuti, l'array viene concatenato in un buffer che viene poi passato al plug-in successivo nella sequenza. Poiché il plug-in opera su risposte, che vengono elaborate in ordine inverso, posizionalo come ultimo plug-in nella sequenza.

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

Le distribuzioni Edge Microgateway includono un plug-in di esempio chiamato <microgateway-root-dir>/plugins/header-uppercase. L'esempio include commenti descrivendo ciascuno dei gestori di funzioni. Questo esempio esegue una semplice trasformazione dei dati e aggiunge intestazioni personalizzate alla richiesta del client e alla risposta target.

Ecco il codice sorgente per <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();
    }

  };

}

trasforma in maiuscolo

Si tratta di un plug-in di trasformazione generale che puoi modificare per svolgere la trasformazione desiderata. Questo esempio trasforma semplicemente i dati della risposta e della richiesta in in maiuscolo.

 */
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);
    }

  };

}