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 avec les 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 Citrix ADC propose des 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 qui produisent une valeur de chaîne | Description |
|---|---|
| str + 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 : http://req.hostname alt client.ip.src |
| Opérations sur les chaînes qui produisent un résultat de TRUE ou FALSE | Description |
|---|---|
| str == str | Evalue si les chaînes de chaque côté de l’opérateur sont les mêmes. Voici un exemple : http.req.header (« myheader ») == http.res.header (« myheader ») |
| str <= str | Évalue si la chaîne située sur le côté gauche de l’opérateur est la même que la chaîne de droite, ou la précède par ordre alphabétique. |
| str >= str | Évalue si la chaîne sur le côté gauche de l’opérateur est la même que la chaîne sur la droite, ou la suit par ordre alphabétique. |
| str < str | Évalue si la chaîne sur le côté gauche de l’opérateur précède la chaîne sur la droite par ordre alphabétique. |
| str > str | Évalue si la chaîne sur le côté gauche de l’opérateur suit la chaîne sur la droite par ordre alphabétique. |
| str !!= str | Evalue 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 joints par l’ET doivent évaluer 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. (« Type de contenu »). Contient (« javascript ») |
| Bool | Effectue un 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 d’expression gauche de l’opérateur à la valeur d’expression de droite. Exemple : http://req.content_length + http.req.url.length |
| num — num | Soustrayez la valeur d’expression droite de l’opérateur de la valeur d’expression de gauche. |
| Num x Num | Multipliez la valeur d’expression gauche de l’opérateur par la valeur d’expression droite. Exemple : client.interface.rxthroughput * 9 |
| num/num | Divisez la valeur d’expression gauche de l’opérateur par la valeur d’expression de 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 » égales à 3 et « 12 mod 4 » sont égales à 0. |
| ~nombre | Renvoie un nombre après avoir appliqué une négation logique au niveau du 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). Toutes les valeurs renvoyées de moins de 32 bits avant d’appliquer l’opérateur ont implicitement des zéros à gauche pour leur donner 32 bits de largeur. |
| nombre ^ nombre | Compare deux modèles de bits de longueur égale 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 au niveau du bit à l’argument entier et à la valeur du nombre actuel. Si les valeurs de la comparaison binaire sont les mêmes, 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). Toutes les valeurs renvoyées de moins de 32 bits avant d’appliquer l’opérateur ont implicitement des zéros à gauche pour leur donner 32 bits de largeur. |
| nombre | nombre | Renvoie un nombre après avoir appliqué un OU au niveau du bit aux valeurs numériques. Si l’une ou l’autre des valeurs de la comparaison binaire 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). Toutes les valeurs renvoyées de moins de 32 bits avant d’appliquer l’opérateur ont implicitement des zéros à gauche pour leur donner 32 bits de largeur. |
| numéro & numéro | Compare deux modèles de bits de longueur égale et effectue une opération AND sur chaque paire de bits correspondants, renvoyant 1 si les deux bits contiennent une valeur de 1, et 0 si les deux bits sont 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). Toutes les valeurs renvoyées de moins de 32 bits avant d’appliquer l’opérateur ont implicitement des zéros à gauche pour leur donner 32 bits de largeur. |
| 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. Le nombre de bits décalés est entier modulo 32. L’exemple suivant suppose que numeric.expression1 renvoie 12 (binaire 1100) et numérique.expression2 renvoie 3 : numeric.expression1 « numérique.expression2 Le résultat de l’application de l’opérateur LSHIFT est 96 (un binaire 1100000). Toutes les valeurs renvoyées de moins de 32 bits avant d’appliquer l’opérateur ont implicitement des zéros à gauche pour leur donner 32 bits de largeur. |
| 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. Le nombre de bits décalés est 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). Toutes les valeurs renvoyées de moins de 32 bits avant d’appliquer l’opérateur ont implicitement des zéros à gauche pour leur donner 32 bits de largeur. |
| 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égie Citrix ADC 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’appliquent 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
- Longue non signée
- 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.