Beispiele für GatewayScript-Codes

Beispiel- GatewayScript -Code-Snippets zur Unterstützung bei der Erstellung einer gatewayscript -Richtlinie.

Achtung:

Die hier beschriebenen Mechanismen für die Interaktion mit dem API Connect-Kontext sind für v5-compatible-Gateways gedacht und sollen auch v5-Kompatibilität für APIs bieten, die für das API Gateway erstellt wurden. Das v5-compatible Gateway ist in API Connect Enterprise as a Service nicht verfügbar, Daher müssen Sie die in Verwendung von Kontextvariablen in GatewayScript beschriebenen Mechanismen und XSLT-Richtlinien mit dem DataPower API Gateway verwenden. Für API Gateway -APIs dürfen die hier aufgeführten v5-compatibility nur für die Migration von v5 verwendet werden.
Die hier aufgeführten GatewayScript-Funktionen verwenden den allgemeinen Namen apim, um die Methoden aufzurufen. Sie können den allgemeinen Namen jedoch mithilfe einer der folgenden Funktionsaufrufe in einen Namen Ihrer Wahl ändern, je nach verwendetem Gateway-Typ:
```
var name = require('local:///isp/policy/apim.custom.js');   // v5-Compatible Gateway
var name = require('apim');                                 // DataPower API Gateway
```
Dabei steht name für den von Ihnen ausgewählten Namen, wie z. B.:
```
var apim = require('apim');
```

Zugriff auf den Assembly-Kontext

Die folgenden Codeausschnitte zeigen Beispiele dazu, wie auf den Assembly-Kontext zugegriffen werden kann.

Beispiel 1 gibt den request-Kontext zurück:

apim.getvariable('request');

Beispiel 2 gibt den Header namens myheader zurück:

apim.getvariable('request.headers.myheader');

In Beispiel drei wird das Festlegen, Hinzufügen oder Löschen einer Kontextvariable, in diesem Fall eines Nachrichtenheaders, veranschaulicht:

apim.setvariable('message.headers.name', value, action)

Name ist der Name des Nachrichtenheaders, den Sie festlegen, hinzufügen oder löschen möchten.
value ist der Zeichenfolgewert, auf den Sie die Variable setzen möchten. Dabei kann es sich um einen Literalwert oder um eine andere Variable handeln. Um beispielsweise Ihre benannte Variable auf den Wert des Inhaltstyp-Headers (content-type) in einer Anforderung zu setzen, geben Sie für Wert Folgendes ein: request.headers.content-type. Diese Eigenschaft ist nur erforderlich, wenn als Aktion set oder add angegeben ist.
Aktion ist die Aktion, die auf die Variable angewendet werden soll. Gültige Optionen sind:
- set
- add
- clear
Ist keine Option festgelegt, wird die Standardoption set angewendet.

Eine vollständige Liste der Kontextvariablen enthält der Abschnitt API Gateway -Kontextvariablen. Weitere Informationen zum Referenzieren von Kontextvariablen in IBM API Connect finden Sie unter Variablenreferenzen in API Connect. Wenn Sie die DataPower® API Gatewayverwenden, lesen Sie auch Kontextvariablen in GatewayScript und XSLT-Richtlinien mit dem DataPower API Gateway.

Synchrones Lesen von Eingaben

Die folgenden Codeausschnitte zeigen Beispiele dazu, wie Eingaben mithilfe der Funktion apim.getvariable zum Lesen von Daten direkt aus einem Kontext synchron gelesen werden können. JSON-Eingaben werden als JavaScript-Objekt zurückgegeben. XML-Daten werden als NodeList-Objekt (DOM) zurückgegeben.

Beispiel 1 gibt eine synchrone Ablesung des ursprünglichen Anforderungshauptteils in die Variable namens json zurück:

var json = apim.getvariable('request.body');

Beispiel 2 gibt eine synchrone Ablesung der aktuellen Nachricht in die Variable namens xml zurück:

var xml = apim.getvariable('message.body');

Hinweis: Wenn der Inhaltstyp der Daten weder XML noch JSON ist, gibt die Funktion apim.getvariable() ein NodeList -Objekt zurück, das aus einem binären Knoten besteht, der in eine Zeichenfolge konvertiert werden muss. Wenn der Inhalt tatsächlich XML oder JSON ist, müssen Sie diese Zeichenfolge analysieren, wie im folgenden Beispiel dargestellt:

var data = apim.getvariable('request.body');

// if a nodelist was returned and the type is 13 (BLOB/Binary Node), convert it
// to a Buffer, which can then be converted to a string
if ((data.item && data.length > 0 && data.item(0).nodeType === 13)) {
  data = data.item(0).toBuffer().toString();
}

// if the string really is XML or JSON, then now add code to parse it with
// the appropriate XML or JSON parse function
      .
      .
      .

Asynchrones Lesen von Eingaben

Die folgenden Codeausschnitte zeigen die apim.readInput()-Aufrufe, die Sie verwenden können, um eine JavaScript-Callback-Funktion durchzuführen, um Eingabedaten asynchron in eine Variable einzulesen. JSON-Eingaben werden als JavaScript-Objekt zurückgegeben. XML-Daten werden als NodeList-Objekt (DOM) zurückgegeben. Andere Eingabetypen werden als Pufferobjekt zurückgegeben.

apim.readInput(callback(err,input) {});
apim.readInputAsJSON(callback(err,json) {});
apim.readInputAsXML(callback(err,nodelist) {});
apim.readInputAsBuffer(callback(err,buffer) {});

Hinweis: Die Funktion apim.readInput() versucht, den Eingabedatentyp zu bestimmen, und ruft die entsprechende Funktion apim.readInputAstype() auf, um die Daten im richtigen Format zurückzugeben. Um sicherzustellen, dass der richtige Datentyp zurückgegeben wird, verwenden Sie jedoch die Funktion apim.readInputAstype() .

Die Funktion apim.readInputAstype() liest die Daten entweder aus dem INPUT-Kontext (z. B. session.INPUT) oder aus einem Richtlinienausgabekontext (z. B. policy.output), je nachdem, ob eine vorherige Richtlinie aufgerufen wurde, die eine Ausgabe in einen Richtlinienausgabekontext geschrieben hatte. Diese Funktion ruft dann die zugrunde liegende IBM DataPower GatewayScript readAstype -Methode im relevanten Kontext auf, um die Daten zu lesen, und verwendet anschließend JavaScript -Callbacks, um die Daten an eine Variable zurückzugeben. Weitere Informationen zu DataPower -Methoden finden Sie unter Gateway-Programmiermodell und GatewayScript.

Beim Folgenden handelt es sich um ein Beispiel dafür, wie die apim.readInputAsJSON()-Callback-Funktion dazu verwendet wird, Daten in eine Variable namens json aufzunehmen:

apim.readInputAsJSON(function (error, json) {
if (error)
{
// handle error
}
else
{
// the json parameter will contain the json data that has been read
// process the json object in some way and write to the output context
if (json.test=='true') 
{
// if json data contains a variable called test that is set to true, then also add some test data
json.data = 'This is my test data'
}
session.output.write(json); 
// write to the output context
}
});

Konfigurieren von Fehlerinformationen

Der folgende Codeblock enthält ein Beispiel dafür, wie die Richtlinienimplementierung mithilfe der Funktion apim.error() zum Ausgeben von Fehlerinformationen konfiguriert werden kann. In diesem Beispiel wird MyError an den Assembly-Ablauf ausgegeben. Wenn ein Catch-Handler vorhanden ist, fängt er diesen Fehler ab; andernfalls überspringt die Assembly die Ausführung des Ablaufs und sendet einen Fehler vom Typ 500 Internal Error als Antwort.

apim.error('MyError', 500, 'Internal Error', 'Some error message');

Dabei gilt:

MyError ist der Name des Fehlers.
500 ist der HTTP-Code der erforderlichen Fehlernachricht.
Internal Error ist der HTTP-Ursachenausdruck für den Fehler.
Some error message ist die vorgeschlagene Aktion für den Benutzer.

Auf die abgefangene Ausnahmebedingung in einem Catch-Block zugreifen

Das folgende Beispiel zeigt, wie Sie im catch-Block einer API-Assembly die Details der aktuellen abgefangenen Ausnahmebedingung abrufen können. Eine mögliche Verwendung wäre die Erstellung einer angepassten Fehlerantwort unter Verwendung der Details der abgefangenen Ausnahmebedingung.

let exception = apim.getError();

Die Funktion gibt ein JSON-Objekt zurück. Beispiel:

{
  "name": "OperationError",
  "message": "This is a thrown Operation Error",
  "policyTitle": "Throw Operation Error",
  "status": {
    "code": "500",
    "reason": "Internal Server Error"
  }
}

Schreiben einer Ausgabe

Im folgenden Beispiel wird gezeigt, wie Daten, in diesem Fall die JSON-Daten '{ "status": "created" }', mithilfe der Variable session.output.write in die Ausgabe geschrieben werden:

session.output.write('{ "status": "created" }');

Die Variable session.output.write ist eine Standard-GatewayScript-Methode, mit der Daten in den Ausgabekontext geschrieben werden. Weitere Informationen finden Sie unter Kontexte und Sitzungen.

Verwenden Sie die folgende Funktion, um das Format des Inhalts festzulegen, der in die Variable session.output geschrieben wird:

apim.output('application/type');

Wenn Sie beispielsweise eine Richtlinie erstellt haben, die Folgendes aufgerufen hat:

session.output.write('<test>this is some xml data</test>');

Die Richtlinie würde XML-Daten in den Ausgabekontext schreiben. Sie müssen die Richtlinie so konfigurieren, dass auch

apim.output('application/xml');

um dem System mitzuteilen, dass die Ausgabe XML ist. Es kann zu Problemen bei der Verarbeitung der Richtlinie kommen, wenn das tatsächliche Ausgabekontextformat und das in apim.output angegebene Format unterschiedlich sind.

Hinweis: Wenn Sie apim.setvariable zum Bearbeiten von message.bodyverwenden, müssen Sie dem Funktionsaufruf apim.setvariable sofort mit einem Funktionsaufruf apim.output folgen, der den Inhaltstyp der Nutzdaten angibt, die von apim.setvariablein message.body geschrieben wurden.