Expressions de stratégie avancées composées
Vous pouvez configurer une expression de stratégie avancée avec des opérateurs booléens ou arithmétiques et des opérations atomiques. L’expression composée suivante a un AND booléen :
http.req.hostname.eq("mycompany.com") && http.req.method.eq(post)
L’expression suivante ajoute la valeur de deux cibles et compare le résultat à une troisième valeur :
http.req.url.length + http.req.cookie.length \<= 500
Une expression composée peut comporter un certain nombre d’opérateurs logiques et arithmétiques.
L’expression suivante évalue la longueur d’une requête HTTP. Cette expression est basée sur l’URL et le cookie. Cette expression évalue le texte de l’en-tête. De plus, un AND booléen fait sur ces deux résultats :
http.req.url.length + http.req.cookie.length \<= 500 && http.req.header.contains("some text")
Vous pouvez utiliser des parenthèses pour contrôler l’ordre d’évaluation dans une expression composée.
Booléens dans les expressions composées
Vous configurez des expressions composées à l’aide des opérateurs suivants :
-
&&.
Cet opérateur est un AND logique. Pour que l’expression soit évaluée à TRUE, tous les composants doivent être évalués à TRUE.
Exemple :
http.req.url.hostname.eq(“myHost”) && http.req.header(“myHeader”).exists
-
||.
Cet opérateur est un OR logique. Si un composant de l’expression est évalué à TRUE, l’expression entière est TRUE.
-
!.
P N’est pas logique sur l’expression.
Parfois, l’utilitaire de configuration NetScaler propose les opérateurs AND, NOT et OR dans la boîte de dialogue Ajouter une expression . Toutefois, ces expressions composées sont d’une utilité limitée. Citrix vous recommande d’utiliser les opérateurs &&, || et ! Pour configurer des expressions composées utilisant la logique booléenne.
Parenthèses dans les expressions composées
Vous pouvez utiliser des parenthèses pour contrôler l’ordre d’évaluation d’une expression. Voici un exemple :
http.req.url.contains("myCompany.com") || (http.req.url.hostname.eq("myHost") && http.req.header("myHeader").exists)
Voici un autre exemple :
(http.req.header("Content-Type").exists && http.req.header("Content-Type").eq("text/html")) || (http.req.header("Transfer-Encoding").exists || http.req.header("Content-Length").exists)
Opérations composées pour les chaînes
Le tableau suivant décrit les opérateurs que vous pouvez utiliser pour configurer des opérations composées sur des données de chaîne.
| Opérations produisant une valeur de chaîne | Description |
|---|---|
| str + | Concatène la valeur de l’expression à gauche de l’opérateur avec la valeur à droite. Exemple : http.req.hostname + http.req.url.protocol |
| str + num | Concatène la valeur de l’expression à gauche de l’opérateur avec une valeur numérique à droite. Exemple : http.req.hostname + http.req.url.content_length |
| num + str | Concatène la valeur numérique de l’expression sur le côté gauche de l’opérateur avec une valeur de chaîne sur la droite. Exemple : http.req.url.content_length + http.req.url.hostname |
| str + ip | Concatène la valeur de chaîne de l’expression sur le côté gauche de l’opérateur avec une valeur d’adresse IP sur la droite. Exemple : http.req.hostname + 10.00.000.00 |
| IP + str | Concatène la valeur de l’adresse IP de l’expression située à gauche de l’opérateur avec une valeur de chaîne à droite. Exemple : client.ip.dst + http.req.url.hostname |
| str1 ALT str2 | Utilise string2 si l’évaluation de string1 entraîne une exception undef ou si le résultat est une chaîne nulle. Sinon, utilise string1 et n’évalue jamais string2. Exemple : ttp.req.hostname alt client.ip.src |
| Opérations sur les chaînes qui produisent un résultat de TRUE ou FALSE | Description |
|---|---|
| str == str | Évalue si les chaînes de chaque côté de l’opérateur sont identiques. Voici un exemple : http.req.header(“myheader”) == http.res.header(“myheader”) |
| str <= str | Évalue si la chaîne située à gauche de l’opérateur est identique à la chaîne de droite ou si elle la précède dans l’ordre alphabétique. |
| str >= str | Évalue si la chaîne située à gauche de l’opérateur est identique à la chaîne de droite ou si elle la suit dans l’ordre alphabétique. |
| str < str | Évalue si la chaîne située à gauche de l’opérateur précède la chaîne de droite dans l’ordre alphabétique. |
| str > str | Évalue si la chaîne située à gauche de l’opérateur suit la chaîne de droite dans l’ordre alphabétique. |
| str !!= str | Évalue si les chaînes de chaque côté de l’opérateur sont différentes. |
| Opérations logiques sur les chaînes | Description |
|---|---|
| bool && bool | Cet opérateur est un AND logique. Lors de l’évaluation des composants de l’expression composée, tous les composants qui sont joints par le AND doivent être évalués à TRUE. Voici un exemple : http.req.method.eq(GET) && http.req.url.query.contains(“viewReport && my_pagelabel”) |
| bool || bool | Cet opérateur est un OR logique. Lors de l’évaluation des composants de l’expression composée, si un composant de l’expression appartenant à OR est évalué à TRUE, l’expression entière est TRUE. Voici un exemple : http.req.url.contains(“.js”) || http.res.header.(“Content-Type”). Contains(“javascript”) |
| Bool | Effectue une opération NOT logique sur l’expression. |
Opérations composées pour les nombres
Vous pouvez configurer des expressions numériques composées. Par exemple, l’expression suivante renvoie une valeur numérique qui est la somme d’une longueur d’en-tête HTTP et d’une longueur d’URL :
http.req.header.length + http.req.url.length
Les tableaux suivants décrivent les opérateurs que vous pouvez utiliser pour configurer des expressions composées pour des données numériques.
| Opérations arithmétiques sur les nombres | Description |
|---|---|
| num + num | Ajoutez la valeur de l’expression à gauche de l’opérateur à la valeur de l’expression de droite. Voici un exemple : http.req.content_length + http.req.url.length |
| num — num | Soustrayez la valeur de l’expression à droite de l’opérateur de la valeur de l’expression à gauche. |
| num*num | Multipliez la valeur de l’expression à gauche de l’opérateur par la valeur de l’expression à droite. Voici un exemple : client.interface.rxthroughput* 9 |
| num / num | Divisez la valeur de l’expression à gauche de l’opérateur par la valeur de l’expression à droite. |
| num% num | Calculez le modulo, ou le reste numérique sur une division de la valeur de l’expression à gauche de l’opérateur par la valeur de l’expression à droite. Par exemple, les valeurs « 15 mod 4” sont égales à 3 et « 12 mod 4” sont égales à 0. |
| ~number | Renvoie un nombre après avoir appliqué une négation logique bit à bit du nombre. L’exemple suivant suppose que numeric.expression renvoie 12 (binaire 1100) : ~numeric.expression. Le résultat de l’application de l’opérateur ~ est -11 (un binaire 1110011, 32 bits au total avec tous ceux à gauche). Notez que toutes les valeurs renvoyées de moins de 32 bits avant l’application de l’opérateur ont implicitement des zéros à gauche pour les rendre larges de 32 bits. |
| number ^ number | Compare deux modèles de bits de même longueur et effectue une opération XOR sur chaque paire de bits correspondants dans chaque argument numérique, renvoyant 1 si les bits sont différents et 0 s’ils sont identiques. Renvoie un nombre après avoir appliqué un XOR bit à bit à l’argument entier et à la valeur numérique courante. Si les valeurs de la comparaison bit à bit sont identiques, la valeur renvoyée est 0. L’exemple suivant suppose que numeric.expression1 renvoie 12 (binaire 1100) et numeric.expression2 renvoie 10 (binaire 1010) : numeric.expression1 ^ numeric.expression2Le résultat de l’application de l’opérateur ^ à l’ensemble de l’expression est 6 (binaire 0110). Notez que toutes les valeurs renvoyées de moins de 32 bits avant l’application de l’opérateur ont implicitement des zéros à gauche pour les rendre larges de 32 bits. |
| number | number | Renvoie un nombre après avoir appliqué un OR bit à bit aux valeurs numériques. Si l’une des valeurs de la comparaison bit à bit est 1, la valeur renvoyée est 1. L’exemple suivant suppose que numeric.expression1 renvoie 12 (binaire 1100) et numeric.expression2 renvoie 10 (binaire 1010) : numeric.expression1 | numeric.expression2 Le résultat de l’application de l’opérateur | à l’ensemble de l’expression est 14 (binaire 1110). Notez que toutes les valeurs renvoyées de moins de 32 bits avant l’application de l’opérateur ont implicitement des zéros à gauche pour les rendre larges de 32 bits. |
| number & number | Compare deux modèles de bits de même longueur et effectue une opération AND bit à bit sur chaque paire de bits correspondants, renvoyant 1 si les deux bits contiennent une valeur de 1, et 0 si l’un des bits est égal à 0. L’exemple suivant suppose que numeric.expression1 renvoie 12 (binaire 1100) et numeric.expression2 renvoie 10 (binaire 1010) : numeric.expression1 & numeric.expression2 L’expression entière est évaluée à 8 (binaire 1000). Notez que toutes les valeurs renvoyées de moins de 32 bits avant l’application de l’opérateur ont implicitement des zéros à gauche pour les rendre larges de 32 bits. |
| num « num | Renvoie un nombre après un décalage vers la gauche de la valeur de nombre par le nombre d’arguments de droite nombre de bits. Notez que le nombre de bits décalés est un entier modulo 32. L’exemple suivant suppose que numeric.expression1 renvoie 12 (binaire 1100) et numeric.expression2 renvoie 3 : numeric.expression1 « numeric.expression2 Le résultat de l’application de l’opérateur LSHIFT est 96 (un binaire 1100000) .Notez que toutes les valeurs renvoyées sont inférieures à 32 bits avant d’appliquer l’opérateur ont implicitement des zéros à gauche pour leur donner une largeur de 32 bits. |
| num » num | Retourne un nombre après un décalage vers la droite du bit de la valeur du nombre par le nombre entier d’argument de bits. Notez que le nombre de bits décalés est un entier modulo 32. L’exemple suivant suppose que numeric.expression1 renvoie 12 (binaire 1100) et numeric.expression2 renvoie 3 : numeric.expression1 » numeric.expression2 Le résultat de l’application de l’opérateur RSHIFT est 1 (un binaire 0001). Notez que toutes les valeurs renvoyées de moins de 32 bits avant l’application de l’opérateur ont implicitement des zéros à gauche pour les rendre larges de 32 bits. |
| Opérateurs numériques qui produisent un résultat de TRUE ou FALSE | Description | | ———– | —————————————————————————————————————————————— | | num == num | Déterminez si la valeur de l’expression à gauche de l’opérateur est égale à la valeur de l’expression à droite. | | num! = num | Déterminez si la valeur de l’expression située à gauche de l’opérateur n’est pas égale à la valeur de l’expression à droite. | | | num > num | Déterminez si la valeur de l’expression située à gauche de l’opérateur est supérieure à la valeur de l’expression à droite. | | num < num | Déterminez si la valeur de l’expression située à gauche de l’opérateur est inférieure à la valeur de l’expression à droite. | | num >= num | Déterminez si la valeur de l’expression située à gauche de l’opérateur est supérieure ou égale à la valeur de l’expression à droite. | | num <= num | Déterminez si la valeur de l’expression située à gauche de l’opérateur est inférieure ou égale à la valeur de l’expression à droite |
Fonctions pour les types de données dans l’infrastructure de stratégie
L’infrastructure de stratégies NetScaler prend en charge les types de données numériques suivants :
- Entier (32 bits)
- Long non signé (64 bits)
- Double (64 bits)
Les expressions simples peuvent renvoyer tous ces types de données. Vous pouvez également créer des expressions composées qui utilisent des opérateurs arithmétiques et des opérateurs logiques pour évaluer ou renvoyer les valeurs de ces types de données. Vous pouvez également utiliser toutes ces valeurs dans des expressions de stratégie. Les constantes littérales de type unsigned long peuvent être spécifiées en ajoutant la chaîne ul au nombre. Les constantes littérales de type double contiennent un point (.), un exposant ou les deux.
Opérateurs arithmétiques, opérateurs logiques et promotion de type
Dans les expressions composées, les opérateurs arithmétiques et logiques standard suivants peuvent être utilisés pour les types de données longues doubles et non signées :
- +, -, * et/
-
%, ~, ^, &, , «, et » (ne s’applique pas au double) - ==, ! =, >, <, >= et <=
Tous ces opérateurs ont la même signification que dans le langage de programmation C.
Dans tous les cas d’opérations mixtes entre des opérandes de type entier, long non signé et double. La promotion de type est effectuée pour effectuer l’opération sur les opérandes du même type. L’opération promeut un type de priorité inférieure à l’opérande ayant le type de priorité la plus élevée. L’ordre de priorité (supérieur à inférieur) est le suivant :
- Double
- Long non signé
- Nombre entier
Ainsi, une opération qui renvoie un résultat numérique renvoie un résultat du type le plus élevé impliqué dans l’opération.
Par exemple, si les opérandes sont de type entier et non signé long, l’opérande entier est automatiquement converti en type unsigned long. Cette conversion de type s’effectue dans des expressions simples. Le type de données identifié par le préfixe d’expression ne correspond pas au type de données transmises en tant qu’argument à la fonction. Dans l’opération HTTP.REQ.CONTENT_LENGTH.DIV (3ul), le préfixe HTTP.REQ.CONTENT_LENGTH.DIV renvoie un entier qui devient long non signé. Long non signé : le type de données transmis comme argument à la fonction DIV (), une division longue non signée est effectuée. De même, l’argument peut être promu dans une expression. Par exemple, HTTP.REQ.HEADER (« MyHeader ») .TYPECAST_DOUBLE_AT.DIV (5) promeut l’entier 5 à taper double et effectue une division à double précision.
Pour plus d’informations sur les expressions permettant de transférer des données d’un type vers des données d’un autre type, reportez-vous à la section Données de typage.