Funktionen

Funktionen sind ein grundlegender Baustein der Programmierung — sie sind eine bequeme und leistungsfähige Möglichkeit, Anweisungen zu gruppieren, die eine Aufgabe ausführen. Sie sind die Schnittstelle zwischen der Citrix ADC Appliance und dem Erweiterungscode. Für Richtlinien definieren Sie Richtlinienerweiterungsfunktionen. Bei Protokollen implementieren Sie Callback-Funktionen für das Protokollverhalten. Funktionen bestehen aus Funktionsdefinitionen, die angeben, welche Werte in und aus der Funktion übergeben werden und welche Anweisungen für die Funktion ausgeführt werden, und Funktionsaufrufe, die Funktionen mit bestimmten Eingabedaten ausführen und Ergebnisse aus der Funktion erhalten.

Callback-Funktionen des Protokollverhaltens

Das TCP-Clientverhalten besteht aus einer Callback-Funktion (on_data), die TCP-Client-Datenstream-Ereignisse verarbeitet. Um Message Based Load Balancing (MBLB) für ein TCP-basiertes Protokoll zu implementieren, können Sie Code für diese Callback-Funktion hinzufügen, um den TCP-Datenstrom vom Client zu verarbeiten und den Bytestream in Protokollmeldungen zu analysieren.

Die Callback-Funktionen in einem Verhalten werden mit einem Kontext aufgerufen, der der Verarbeitungsmodulstatus ist. Der Kontext ist die Instanz des Verarbeitungsmoduls. Beispielsweise werden die TCP-Clientverhalten Callbacks mit unterschiedlichen Kontexten für verschiedene Client-TCP-Verbindungen aufgerufen.

Zusätzlich zum Kontext können die Verhaltensrückrufe andere Argumente haben. Normalerweise werden die restlichen Argumente als Payload übergeben, was die Sammlung aller Argumente ist. So können die programmierbaren Verarbeitungsmodulinstanzen als eine Kombination aus Instanzstatus plus Ereignisrückruffunktionen gesehen werden, dh dem Kontext plus Verhalten. Und der Verkehr fließt durch die Pipeline als Ereignisnutzlast.

Prototyp der TCP-Client-Callback-Funktion:

                           Funktions-Client on_data (ctxt, payload)

                                            //.code

            Ende

Wobei:

• ctxt - TCP-Clientverarbeitungskontext
• Nutzlast — Ereignisnutzlast
  • payload.data - Empfangene TCP-Daten, verfügbar als Bytestrom

Richtlinienerweiterungsfunktionen

Da die NetScaler Richtlinienausdruckssprache stark typisiert ist, muss die Definition einer Erweiterungsfunktion die Typen ihrer Eingaben und ihren Rückgabewert angeben. Die Lua-Funktionsdefinition wurde um folgende Typen erweitert:

function self-type:function-name(parameter1: parameter1-type, etc.): return-type
     statements
end

where,

the types are NSTEXT, NSNUM, NSBOOL, or NSDOUBLE.

Selbsttyp ist der Typ des impliziten Selbstparameters, der an die Funktion übergeben wird. Wenn die Erweiterungsfunktion in einem Citrix ADC Richtlinienausdruck verwendet wird, ist dies der Wert, der vom Ausdruck links neben der Funktion generiert wird. Eine andere Möglichkeit, dies anzuzeigen, besteht darin, dass die Funktion diesen Typ in der Citrix ADC Richtliniensprache erweitert.

Die Parametertypen sind die Typen jedes Parameters, der im Aufruf der Erweiterungsfunktion im Richtlinienausdruck angegeben wird. Eine Erweiterungsfunktion kann null oder mehr Parameter haben.

return-type ist der Typ des Wertes, der durch den Aufruf der Erweiterungsfunktion zurückgegeben wird. Es ist die Eingabe für den Teil des Richtlinienausdrucks, falls vorhanden, rechts von der Funktion, oder andernfalls ist der Wert des Ausdrucksergebnisses.

Beispiel:

function NSTEXT:COMBINE_HEADERS() : NSTEXT

Verwendung der Erweiterungsfunktion in einer Richtlinienausdrücke:

HTTP.REQ.FULL_HEADER.AFTER_STR("HTTP/1.1rn").COMBINE_HEADERS()

Hier ist der self Parameter das Ergebnis von HTTP.REQ.FULL_HEADER.AFTER_STR (“HTTP/1.1rn”), was ein Textwert ist. Das Ergebnis des COMBINE_HEADERS () -Aufrufs ist Text, und da sich nichts rechts neben diesem Aufruf befindet, ist das Ergebnis des gesamten Ausdrucks Text.

Lokale Funktionsdefinition

Neben Erweiterungsfunktionen können keine globalen Funktionen in einer Erweiterungsdatei definiert werden. Aber lokale Funktionen können innerhalb von Erweiterungsfunktionen mit der normalen Lua-Funktionsanweisung definiert werden. Dies deklariert den Namen der Funktion und die Namen ihrer Parameter (auch als Argumente bezeichnet), und wie alle Deklarationen in Lua werden keine Typen angegeben. Die Syntax dafür ist:

local function function-name(parameter1-name, parameter2-name, etc.)
     statements
end

Die Funktions- und Parameternamen sind alle Bezeichner. (Der Funktionsname ist eigentlich eine Variable und die Funktionsanweisung ist Abkürzung für lokale Funktionsname = Funktion (Parameter1 usw.), aber Sie müssen diese Subtilität nicht verstehen, um Funktionen zu verwenden.)

Beachten Sie, dass usw. hier für die Fortsetzung des Musters von Parameternamen anstelle des üblichen… verwendet wird. Dies liegt daran, dass… selbst tatsächlich eine Variablen-Parameterliste bedeutet, die hier nicht diskutiert wird.

Funktionskörper und Rücklauf

Der Block von Anweisungen zwischen Funktion und End-Anweisung ist der Funktionskörper. Im Funktionskörper wirken die Funktionsparameter wie lokale Variablen, mit Werten, die von den Funktionsaufrufen bereitgestellt werden, wie zuvor beschrieben.

Die return-Anweisung liefert Werte an den Aufrufer der Funktion zurückgegeben werden. Es muss am Ende eines Blocks erscheinen (in einer Funktion, wenn dann, für Schleife, und so weiter; Es kann in seinem eigenen Block sein tun Rückkehr… Ende). Es kann keine, einen oder mehrere Rückgabewerte angeben:

return -- returns nil
return expression -- one return value
return expression1, expression2, ... -- multiple return values

Beispiele:

local function fsum(a)
     local sum = 0
     for i = 1, #a do
          sum = sum + a[i]
     end
     return sum
end

local function fsum_and_average(a)
     local sum = 0
     for i = 1, #a do
          sum = sum + a[i]
     end
     return sum, sum/#a
end

Funktionsaufrufe

Ein Funktionsaufruf führt den Körper einer Funktion aus, liefert Werte für ihre Parameter und empfängt Ergebnisse. Die Syntax für einen Funktionsaufruf ist Funktionsname (expression1, expression2 usw.), wobei die Funktionsparameter auf die entsprechenden Ausdrücke gesetzt werden. Die Anzahl der Ausdrücke und Parameter muss nicht gleich sein. Wenn weniger Ausdrücke als Parameter vorhanden sind, werden die übrigen Parameter auf nil gesetzt. Sie können also einen oder mehrere Parameter am Ende des Aufrufs optional machen, und Ihre Funktion kann überprüfen, ob sie angegeben sind, indem Sie überprüfen, ob sie nicht Null sind. Eine übliche Möglichkeit, dies zu tun, ist mit der Operation oder:

function f(p1, p2) -- p2 is optional
     p2 = p2 or 0 -- if p2 is nil, set to a default of 0
     . . .
end

Wenn mehr Ausdrücke als Parameter vorhanden sind, werden die verbleibenden Ausdruckswerte ignoriert.

Wie bereits erwähnt, können Funktionen mehrere Werte zurückgeben. Diese Rückgaben können in einer Mehrfachzuweisungsanweisung verwendet werden. Beispiel:

local my_array = {1, 2, 3, 4}
local my_sum, my_ave = sum_and_average(my_array)

Iterator-Funktionen und generische for-Schleifen

Jetzt, da wir Funktionen eingeführt haben, können wir über generische for-Schleifen sprechen. Die Syntax für die generische for-Schleife (mit einer Variablen) lautet:

for variable in iterator(parameter1, parameter2, etc.) do
     statements in the for loop body
end

wobei iterator () eine Funktion mit null oder mehr Parametern ist, die für jede Iteration des Schleifenkörpers einen Wert für Variable bereitstellt. Die Iteratorfunktion verfolgt, wo sie sich in der Iteration befindet, indem sie eine Technik namens Closure verwendet, über die Sie sich hier keine Sorgen machen müssen. Es signalisiert das Ende der Iteration, indem null zurückgegeben wird. Iterator-Funktionen können mehr als einen Wert für die Verwendung in einer Mehrfachzuweisung zurückgeben.

Das Schreiben einer Iteratorfunktion ist jenseits des Rahmens dieses Papiers, aber es gibt eine Reihe nützlicher integrierter Iteratoren, die das Konzept veranschaulichen. Eins ist der Paare () Iterator, der durch die Einträge in einer Tabelle iteriert und zwei Werte zurückgibt, den Schlüssel und den Wert des nächsten Eintrags.

Beispiel:

local t = {k1 = "v1", k2 = "v2", k3 = "v3"}
local a = {} -- array to accumulate key-value pairs
local n = 0 -- number of key-value pairs
for key, value in pairs(t) do
     n = n + 1
     a[n] = key .. " = " .. value -- add key-value pair to the array
end
local s = table.concat(a, "; ") -- concatenate all key-value pairs into one string

Ein weiterer nützlicher Iterator ist die string.gmatch () Funktion, die im folgenden COMBINE_HEADERS () Beispiel verwendet wird.