Benutzerdefinierte Plug-ins entwickeln

<ph type="x-smartling-placeholder"></ph> Sie sehen die Dokumentation zu Apigee Edge.
Gehen Sie zur Apigee X-Dokumentation. Weitere Informationen

Edge Microgateway Version 2.3.x

Zielgruppe

Dieses Thema richtet sich an Entwickler, die Edge Microgateway-Features durch benutzerdefinierten Plug-ins. Wenn Sie ein neues Plug-in schreiben möchten, sollten Sie mit JavaScript und Node.js vertraut sein erforderlich.

Was ist ein benutzerdefiniertes Edge Microgateway-Plug-in?

Ein Plug-in ist ein Node.js-Modul, das Edge Microgateway um Funktionen ergänzt. Plug-in-Module einem einheitlichen Muster folgen und an einem Edge Microgateway bekannten Speicherort gespeichert werden, dass sie erkannt und automatisch ausgeführt werden. Wenn Sie eine der folgenden Optionen nutzen, stehen Ihnen mehrere vordefinierte Plug-ins zur Verfügung: Edge Microgateway installieren. Dazu gehören Plug-ins für Authentifizierung, Spike Arrest, Kontingent- und Analytics. Diese vorhandenen Plug-ins werden unter Plug-ins verwenden beschrieben.

Sie können dem Microgateway neue Funktionen hinzufügen, indem Sie custom . Standardmäßig ist Edge Microgateway im Wesentlichen ein sicherer Passthrough-Proxy, übergibt Anfragen und Antworten unverändert an und von Zieldiensten. Mit benutzerdefinierten Plug-ins können Sie programmatisch mit den Anfragen und Antworten interagieren, die über das Microgateway fließen.

Benutzerdefinierten Plug-in-Code einfügen

Die Edge Microgateway-Installation enthält einen Ordner für benutzerdefinierte Plug-ins hier:

[prefix]/lib/node_modules/edgemicro/plugins

Dabei ist [prefix] das npm-Präfixverzeichnis als beschrieben in „Wo ist Edge Microgateway installiert?“ in Edge installieren Microgateway

Sie können dieses Standard-Plug-in-Verzeichnis ändern. Hier finden Sie Plug-ins.

Vordefinierte Plug-ins überprüfen

Bevor Sie versuchen, Ihr eigenes Plug-in zu entwickeln, überprüfen Sie am besten, ob keine der vordefinierten die Ihren Anforderungen entsprechen. Diese Plug-ins befinden sich hier:

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

Dabei ist [prefix] das Präfixverzeichnis npm. Weitere Informationen finden Sie unter auch „Wo ist Edge Microgateway installiert?“ in Edge installieren Microgateway

Weitere Informationen finden Sie unter Vordefinierte mit Edge Microgateway bereitgestellte Plug-ins.

Einfaches Plug-in schreiben

In diesem Abschnitt werden die Schritte zum Erstellen eines einfachen Plug-ins erläutert. Dieses Plug-in überschreibt die Antwortdaten (was auch immer sie sind) mit der Zeichenfolge "Hello, World!" und druckt sie im .

  1. Wenn Edge Microgateway ausgeführt wird, beenden Sie es jetzt:
    edgemicro stop
  2. cd in das benutzerdefinierte Plug-in-Verzeichnis:

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

    wobei [prefix] das Präfixverzeichnis npm ist wie unter "Wo ist Edge Microgateway installiert ist" beschrieben in Edge installieren Microgateway

  3. Neues Plug-in-Projekt erstellen response-override und cd hinzu:
    mkdir response-override && cd response-override
  4. Erstellen Sie ein neues Node.js-Projekt:
    npm init
     Drücken Sie mehrmals auf die Eingabetaste, um die Standardeinstellungen zu übernehmen.
  5. Erstellen Sie mit einem Texteditor eine neue Datei namens index.js.
  6. Kopieren Sie den folgenden Code in index.js und speichern Sie die Datei.
    '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. Jetzt haben Sie ein Plug-in erstellt und müssen es der Edge Microgateway-Konfiguration hinzufügen. Öffnen Sie die Datei $HOME/.edgemicro/[org]-[env]-config.yaml, Dabei sind org und env Ihre Edge-Organisation und Umgebungsnamen.
  8. Plug-in response-override hinzufügen zu plugins:sequence-Element wie unten gezeigt.
          ...
      
      plugins:
        dir: ../plugins
        sequence:
          - oauth
          - response-override
          
      ...
  9. Starten Sie Edge Microgateway neu.
  10. API über Edge Microgateway aufrufen. Bei diesem API-Aufruf wird davon ausgegangen, dass Sie Konfiguration wie in der Anleitung mit der Sicherheit des API-Schlüssels beschrieben, wie unter Festlegen Edge Microgateway konfigurieren:
    curl -H 'x-api-key: uAM4gBSb6YoMvTHfx5lXJizYIpr5Jd' http://localhost:8000/hello/echo
Hello, World!

Aufbau eines Plug-ins

Das folgende Edge Microgateway-Beispiel-Plug-in veranschaulicht das Muster, das beim die Entwicklung eigener Plug-ins. Der Quellcode für das in diesem Abschnitt beschriebene Beispiel-Plug-in ist im plugins/header-uppercase/index.js.

  • Plug-ins sind Standard-NPM-Module mit ein package.json und index.js im Stamm Ordner.
  • Ein Plug-in muss eine init()-Funktion exportieren.
  • Die Funktion init() nimmt drei Argumente: config, logger, und stats. Diese Argumente werden beschrieben in Plug-in-Funktionsargumente init().
  • init() gibt ein Objekt mit benannten Funktions-Handlern zurück, die aufgerufen werden. Bestimmte Ereignisse treten während der Lebensdauer einer Anfrage auf.

Event-Handler-Funktionen

Ein Plug-in muss einige oder alle dieser Event-Handler-Funktionen implementieren. Implementierung welche Funktionen Sie nutzen. Jede gegebene Funktion ist optional und ein typisches Plug-in wird unter zumindest eine Teilmenge dieser Funktionen.

Flow-Event-Handler anfordern

Diese Funktionen werden bei Anfrageereignissen in Edge Microgateway aufgerufen.

  • onrequest
  • ondata_request
  • onend_request
  • onclose_request
  • onerror_request

onrequest -Funktion

Wird zu Beginn der Clientanfrage aufgerufen. Diese Funktion wird ausgelöst, wenn das erste Byte des Anfrage wird von Edge Microgateway empfangen. Mit dieser Funktion erhalten Sie Zugriff auf die Anfrageheader, URL, Suchparameter und HTTP-Methode. Wenn Sie "Next" mit dem ersten Argument der Wahrheit (z. B. Fehlerinstanz), wird die Verarbeitung der Anfrage gestoppt und es wird keine Zielanfrage initiiert.

Beispiel:

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

ondata_request -Funktion

Wird aufgerufen, wenn ein Datenblock vom Client empfangen wird. Übergibt Anfragedaten an die nächste in der Plug-in-Sequenz ein. Der vom letzten Plug-in in der Sequenz zurückgegebene Wert wird an das Ziel zu erreichen. Ein typischer Anwendungsfall (siehe unten) ist die Transformation der Anfragedaten vor dem Senden zum Ziel hin.

Beispiel:

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

onend_request -Funktion

Wird aufgerufen, wenn alle Anfragedaten vom Client empfangen wurden.

Beispiel:

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

onclose_request-Function

Gibt an, dass die Clientverbindung beendet wurde. Sie können diese Funktion verwenden, wenn der Clientverbindung ist unzuverlässig. Sie wird aufgerufen, wenn die Socket-Verbindung zum Client geschlossen.

Beispiel:

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

onerror_request-Function

Wird aufgerufen, wenn beim Empfang der Clientanfrage ein Fehler auftritt.

Beispiel:

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

Ereignis-Handler für Antwortfluss

Diese Funktionen werden bei Antwortereignissen in Edge Microgateway aufgerufen.

  • onresponse
  • ondata_response
  • onend_response
  • onclose_response
  • onerror_response

onresponse-Function

Wird zu Beginn der Zielantwort aufgerufen. Diese Funktion wird ausgelöst, wenn das erste Byte des Antwort wird von Edge Microgateway empfangen. Mit dieser Funktion erhalten Sie Zugriff auf die Antwortheader und den Statuscode.

Beispiel:

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


ondata_response-Funktion

Wird aufgerufen, wenn ein Datenblock vom Ziel empfangen wird.

Beispiel:

ondata_response: function(req, res, data, next) {
      debug('plugin ondata_response ' + data.length);
      var transformed = data.toString().toUpperCase();
      next(null, transformed);
    }
 <ph type="x-smartling-placeholder">


onend_response-Funktion

Wird aufgerufen, wenn alle Antwortdaten vom Ziel empfangen wurden.

Beispiel:

onend_response: function(req, res, data, next) {
      debug('plugin onend_response');
      next(null, data);
    }
 <ph type="x-smartling-placeholder">

onclose_response-Function

Gibt an, dass die Zielverbindung beendet wurde. Sie können diese Funktion verwenden, wenn der Zielverbindung ist unzuverlässig. Sie wird aufgerufen, wenn die Socket-Verbindung zum Ziel geschlossen.

Beispiel:

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


onerror_response-Funktion

Wird aufgerufen, wenn beim Empfang der Zielantwort ein Fehler auftritt.

Beispiel:

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

Was Sie über die Plug-in-Event-Handler-Funktionen

Plug-in-Event-Handler-Funktionen werden als Reaktion auf bestimmte Ereignisse aufgerufen, die während Edge Microgateway verarbeitet eine bestimmte API-Anfrage.

  • Alle init()-Funktions-Handler (ondata_request, ondata_response usw.) muss den next()-Callback nach Abschluss der Verarbeitung. Wenn Sie keine next() aufrufen, wird die Verarbeitung beendet und die Anfrage bleibt hängen.
  • Das erste Argument für next() kann ein Fehler sein, der Beendigung der Verarbeitungsanfrage.
  • Die Handler ondata_ und onend_ müssen Rufen Sie next() mit einem zweiten Argument auf, das die zu übergebenden Daten enthält. an die Zielgruppe oder die Kundschaft. Dieses Argument kann null sein, wenn das Plug-in eine Zwischenspeicherung durchführt und keine genügend Daten zur Transformation vorhanden sind.
  • Beachten Sie, dass eine einzelne Instanz des Plug-ins verwendet wird, um alle Anfragen und Antworten zu bearbeiten. Möchte ein Plug-in den anfragespezifischen Status zwischen den Aufrufen beibehalten, kann es diesen Status in einem Property, die dem bereitgestellten request-Objekt hinzugefügt wurde. (req), dessen Lebensdauer der Dauer des API-Aufrufs entspricht.
  • Achten Sie darauf, dass alle Fehler abgefangen werden, und rufen Sie next() mit dem Fehler auf. Wenn next() nicht aufgerufen wird, wird der API-Aufruf ausgesetzt.
  • Achten Sie darauf, keine Speicherlecks zu verursachen, da dies die Gesamtleistung von Edge beeinträchtigen kann. Microgateway verwenden und es zum Absturz bringen, wenn der Arbeitsspeicher ausgeht.
  • Achten Sie darauf, dem Node.js-Modell zu folgen und keine rechenintensiven Aufgaben in der Haupt- Thread, da dies die Leistung von Edge Microgateway beeinträchtigen kann.

Über die Funktion „init()“ des Plug-ins

In diesem Abschnitt werden die Argumente beschrieben, die an Funktion init(): config, logger, und stats.

config

Ein Konfigurationsobjekt, das nach dem Zusammenführen der Edge Microgateway-Konfigurationsdatei mit Informationen, die von Apigee Edge heruntergeladen werden, wie Produkte und Kontingente. Sie finden Plug-in-spezifische Konfiguration in diesem Objekt: config.<plugin-name>.

Um einen Konfigurationsparameter namens param mit einem Wert hinzuzufügen, foo in ein Plug-in namens response-override einzufügen, Folgendes in die Datei default.yaml einfügen:

response-override:
    param: foo

Anschließend können Sie wie folgt auf den Parameter im Plug-in-Code zugreifen:

// 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 diesem Fall wird in der Debug-Ausgabe des Plug-ins "foo" ausgegeben:

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

logger

Der Systemprotokoll. Der aktuell verwendete Logger exportiert diese Funktionen, wobei das Objekt ein String, eine HTTP-Anfrage, eine HTTP-Antwort oder eine Fehlerinstanz.

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

Statistiken

Ein Objekt, das die Anzahl der Anfragen, Antworten, Fehler und andere aggregierte Statistiken enthält zu den Anfragen und Antworten, die über eine Microgateway-Instanz gesendet werden.

  • treqErrors: Anzahl der Zielanfragen mit Fehlern.
  • treqErrors – Anzahl der Zielantworten mit Fehlern.
  • statusCodes – Ein Objekt mit Antwortcode wird gezählt:
{
  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 – Die Gesamtzahl der Anfragen.
  • responses – Die Gesamtzahl der Antworten.
  • connections – Die Anzahl der aktiven Zielverbindungen.

Über die Funktion next()

Alle Plug-in-Methoden müssen next() aufrufen, um die nächste in der Serie an (oder der Plug-in-Prozess bleibt hängen). Im Anfragelebenszyklus wird die erste wird onrequest() aufgerufen. Die nächste Methode, die aufgerufen werden soll, die Methode ondata_request(); ondata_request wird jedoch nur aufgerufen, wenn der Parameter -Anforderung Daten enthält, wie z. B. bei einer POST-Anforderung. Die nächste Methode mit dem Namen ist onend_request() und wird aufgerufen, wenn die Anfrageverarbeitung abgeschlossen ist. abgeschlossen. Die onerror_*-Funktionen werden nur im Falle einer und ermöglichen es Ihnen, die Fehler bei Bedarf mit benutzerdefiniertem Code zu behandeln.

Angenommen, Daten werden in der Anfrage gesendet und ondata_request() wird aufgerufen. Die Funktion ruft next() mit zwei Parametern auf:

next(null, data);

Konventionsgemäß wird der erste Parameter verwendet, um Fehlerinformationen zu übermitteln, die Sie dann Handle in einer nachfolgenden Funktion in der Kette ab. Wenn Sie es auf null setzen, angeben, dass keine Fehler vorliegen und die Anfrageverarbeitung normal fortgesetzt werden sollte. Wenn ist dieses Argument wahrheitsgemäß (z. B. ein Fehlerobjekt), dann wird die Verarbeitung der Anforderung beendet und die Anforderung wird an das Ziel gesendet werden.

Der zweite Parameter übergibt die Anfragedaten an die nächste Funktion in der Kette. Wenn Sie keine werden die Anfragedaten unverändert an das Ziel der API übergeben. Sie haben jedoch die Möglichkeit, die Anfragedaten innerhalb dieser Methode zu ändern und die geänderten an das Ziel zu senden. Wenn die Anforderungsdaten beispielsweise XML sind und das Ziel JSON erwartet, können Sie der Methode ondata_request() Code hinzufügen, mit dem (a) Content-Type des Anfrageheaders in application/json und konvertiert den können Sie Daten beliebig an JSON anfordern (z. B. mit einem xml2json-Konverter von Node.js, der von NPM abgerufen wird.

Das könnte so aussehen:

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

In diesem Fall werden die Anforderungsdaten (von denen angenommen wird, dass sie im XML-Format vorliegen) in JSON konvertiert und der transformierte Daten werden über next() an die nächste Funktion in der Anfrage übergeben. bevor sie an das Back-End-Ziel übergeben werden.

Sie können eine weitere Debug-Anweisung hinzufügen, um die transformierten Daten für das Debugging auszugeben. zu verstehen. Beispiel:

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

Info Ausführungsreihenfolge für Plug-in-Handler

Wenn Sie Plug-ins für Edge Microgateway schreiben, müssen Sie die Reihenfolge verstehen, ausgeführt werden.

Wichtig ist, dass Sie beim Angeben einer Plug-in-Sequenz in Edge Microgateway-Konfigurationsdatei, die Anfrage-Handler führen in aufsteigender Reihenfolge, während die Antwort-Handler in absteigender Reihenfolge.

Das folgende Beispiel soll Ihnen helfen, diese Ausführungssequenz zu verstehen.

1. Erstellen Sie drei einfache Plug-ins

Sehen Sie sich das folgende Plug-in an. Es wird lediglich die Konsolenausgabe ausgegeben, wenn die Event-Handler mit dem Namen:

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

Erwägen Sie nun, zwei weitere Plug-ins plugin-2 und plugin-3 mit demselben Code (außer: Ändern Sie die console.log()-Anweisungen auf plugin-2 bzw. plugin-3).

2. Plug-in-Code überprüfen

Die exportierten Plug-in-Funktionen in <microgateway-root-dir>/plugins/plugin-1/index.js sind Ereignis Handler, die zu bestimmten Zeiten während der Verarbeitung von Anfragen und Antworten ausgeführt werden. Für Beispiel: onrequest führt das erste Byte der Anfrageheader aus, erhalten haben. onend_response wird nach dem letzten Byte der Antwort ausgeführt. Daten empfangen werden.

Sehen Sie sich den Handler ondata_response an. Er wird immer dann aufgerufen, wenn ein Teil der Antwortdaten empfangen wird. Wichtig zu wissen ist, dass die Antwortdaten nicht unbedingt einmal. Stattdessen können die Daten in Blöcken beliebiger Länge empfangen werden.

3. Plug-ins hinzufügen zu Plug-in-Sequenz

Wenn wir mit diesem Beispiel fortfahren, fügen wir die Plug-ins zur Plug-in-Sequenz in Edge hinzu. Microgateway-Konfigurationsdatei (~./edgemicro/config.yaml) folgendermaßen: Die Reihenfolge ist wichtig. Er definiert die Reihenfolge, in der die Plug-in-Handler ausgeführt werden.

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

4. Debug-Ausgabe untersuchen

Werfen wir nun einen Blick auf die Ausgabe, die erzeugt wird, wenn diese Plug-ins aufgerufen werden. Es gibt Beachten Sie die folgenden wichtigen Punkte:

  • Die Plug-in-Sequenz der Edge Microgateway-Konfigurationsdatei (~./edgemicro/config.yaml) gibt die Reihenfolge an, in der Event-Handler ausgeführt werden. aufgerufen.
  • Request-Handler werden in aufsteigender Reihenfolge aufgerufen (die Reihenfolge in die in der Plug-in-Sequenz 1, 2, 3) vorkommen.
  • Antwort-Handler werden in absteigender Reihenfolge aufgerufen: 3, 2, 1.
  • Der Handler ondata_response wird für jeden Datenblock einmal aufgerufen. das ankommt. In diesem Beispiel (siehe unten) werden zwei Blöcke empfangen.

Hier sehen Sie ein Beispiel für eine Debug-Ausgabe, die generiert wird, wenn diese drei Plug-ins verwendet werden und eine Anfrage gesendet wird über Edge Microgateway. Beachten Sie die Reihenfolge, in der die Handler aufgerufen werden:

  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

Zusammenfassung

Es ist sehr wichtig zu verstehen, in welcher Reihenfolge Plug-in-Handler aufgerufen werden, wenn Sie versuchen, Benutzerdefinierte Plug-in-Funktionen implementieren, z. B. zum Sammeln und Umwandeln von Anfragen oder Antworten Daten.

Denken Sie daran, dass Anfrage-Handler in der Reihenfolge ausgeführt werden, in der die Plug-ins die in der Edge Microgateway-Konfigurationsdatei angegeben sind, und Antwort-Handler werden im in entgegengesetzter Reihenfolge.

Globale Variablen in Plug-ins verwenden

Jede Anfrage an Edge Microgateway wird an dieselbe Instanz eines Plug-ins gesendet. Daher ist ein Der Status der zweiten Anfrage von einem anderen Client überschreibt den ersten. Der einzige sichere Ort, an dem Das Speichern des Plug-in-Status besteht darin, den Status in einer Eigenschaft des Anfrage- oder Antwortobjekts zu speichern, dessen Lebensdauer ist auf die der Anfrage beschränkt.

Umschreiben von Ziel-URLs in Plug-ins

Hinzugefügt in: v2.3.3

Sie können die Standard-Ziel-URL in einem Plug-in dynamisch überschreiben, indem Sie diese Variablen in Ihr Plug-in Code: req.targetHostname und req.targetPath.

Beispiel-Plug-ins

Diese Plug-ins werden mit Ihrer Edge Microgateway-Installation bereitgestellt. Sie finden sie in der Edge Microgateway-Installation hier:

[prefix]/lib/node_modules/edgemicro/plugins

Dabei ist [prefix] das npm-Präfixverzeichnis als beschrieben in „Wo ist Edge Microgateway installiert?“ in Edge installieren Microgateway

accumulate-request

Dieses Plug-in sammelt Datenblöcke vom Client in einer Array-Eigenschaft, die dem request-Objekts. Wenn alle Anfragedaten empfangen wurden, wird das Array zu einem Zwischenspeicher verkettet. das dann an das nächste Plug-in in der Sequenz übergeben wird. Dieses Plug-in sollte das erste Plug-in sein. in der Sequenz, damit nachfolgende Plug-ins die akkumulierten Anfragedaten erhalten.

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

Dieses Plug-in sammelt Datenblöcke vom Ziel in einer Array-Eigenschaft, die dem -Antwortobjekt. Wenn alle Antwortdaten empfangen wurden, wird das Array zu einem Zwischenspeicher verkettet. das dann an das nächste Plug-in in der Sequenz übergeben wird. Da dieses Plug-in in Antworten, die in umgekehrter Reihenfolge verarbeitet werden, in der Sequenz an.

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 = null;
      if(res._chunks && res._chunks.length) {
        content = Buffer.concat(res._chunks);
      }
      delete res._chunks;
      next(null, content);
    }
 
  };
}

Plug-in mit großem Anfangsbuchstaben

Edge Microgateway-Distributionen enthalten ein Beispiel-Plug-in namens <microgateway-root-dir>/plugins/header-uppercase. Das Beispiel enthält Kommentare, die die einzelnen Funktions-Handler beschreiben. In diesem Beispiel werden einfache Daten Transformation der Zielantwort und fügt der Clientanfrage und dem Ziel benutzerdefinierte Header hinzu Antwort.

Hier ist der Quellcode für <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();
    }

  };

}

Großschreibung umwandeln

Dies ist ein allgemeines Transformations-Plug-in, das Sie für die Sie sich wünschen. In diesem Beispiel werden die Antwort- und Anfragedaten in Großbuchstaben.

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

  };

}

Zusätzliche Plug-in-Anleitungen

Weitere Informationen finden Sie auch im Apigee-Blog: