Expressions de stratégie avancées composées

Vous pouvez configurer une expression de stratégie avancée qui contient des opérateurs booléens ou arithmétiques et plusieurs opérations atomiques. L’expression composée suivante contient 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 contenir n’importe quel nombre d’opérateurs logiques et arithmétiques. L’expression suivante évalue la longueur d’une requête HTTP sur la base de son URL et de son cookie, évalue le texte dans l’en-tête et exécute un AND booléen 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 joints par le Et doivent être évalués à TRUE. Voici un 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 qui est joint par l’OR est évalué à TRUE, l’expression entière est TRUE.

  • !.

    Effectue un NOT logique sur l’expression.

Dans certains cas, l’utilitaire de configuration Citrix ADC propose des opérateurs AND, NOT et OR dans la boîte de dialogue Ajouter une expression. Cependant, ceux-ci sont d’une utilité limitée. Citrix vous recommande d’utiliser les opérateurs &&, ||, et ! pour configurer des expressions composées qui utilisent 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. Voici un 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. Voici un 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. Voici un 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. Voici un exemple : http.req.hostname + 10.00.000.00
ip + str Concatène la valeur d’adresse IP de l’expression à gauche de l’opérateur avec une valeur de chaîne à droite.Foling est un exemple : client.ip.dst + http.req.url.hostname
str1 ALT str2 Utilise la valeur string1 ou string2 dérivée de l’expression de chaque côté de l’opérateur, tant qu’aucune de ces expressions n’est une expression composée. Voici un 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 jointe par l’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 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 de l’expression à gauche de l’opérateur à la valeur de l’expression à 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 avec 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.
~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). Notez que toutes les valeurs renvoyées de moins de 32 bits avant d’appliquer l’opérateur ont implicitement des zéros à gauche pour les rendre 32 bits de large.
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). Notez que toutes les valeurs renvoyées de moins de 32 bits avant d’appliquer l’opérateur ont implicitement des zéros à gauche pour les rendre 32 bits de large.
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). Notez que toutes les valeurs renvoyées de moins de 32 bits avant d’appliquer l’opérateur ont implicitement des zéros à gauche pour les rendre 32 bits de large.
numéro & numéro Compare deux modèles de bits de longueur égale et effectue une opération AND par bit 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). Notez que toutes les valeurs renvoyées de moins de 32 bits avant d’appliquer l’opérateur ont implicitement des zéros à gauche pour les rendre 32 bits de large.
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 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 de moins de 32 bits avant d’appliquer l’opérateur ont implicitement des zéros à gauche pour les rendre 32 bits de large.
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 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 d’appliquer l’opérateur ont implicitement des zéros à gauche pour les rendre 32 bits de large.
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 à 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 à gauche de l’opérateur est supérieure à la valeur de l’expression à droite.
num < num Déterminez si la valeur de l’expression à gauche de l’opérateur est inférieure à la valeur de l’expression à droite.
num >= num Déterminez si la valeur de l’expression à 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 à 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. Par conséquent, vous pouvez créer des expressions composées qui utilisent des opérateurs arithmétiques et des opérateurs logiques pour évaluer ou renvoyer des valeurs de ces types de données. En outre, vous pouvez utiliser toutes ces valeurs dans les 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, non signé long et double, la promotion de type est effectuée de sorte que l’opération peut être effectuée sur des opérandes du même type. Un type de priorité inférieure est automatiquement promu au type de l’opérande avec la priorité la plus élevée impliquée dans l’opération. L’ordre de priorité (supérieur à inférieur) est le suivant :

  • Double
  • Longue non signée
  • Nombre entier

Par conséquent, 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 est effectuée même dans des expressions simples dans lesquelles le type de données identifié par le préfixe d’expression ne correspond pas au type de données qui est passé comme argument à la fonction. Pour illustrer un tel exemple, dans l’opération HTTP.REQ.CONTENT_LENGTH.DIV (3ul), l’entier renvoyé par le préfixe HTTP.REQ.CONTENT_LENGTH est automatiquement converti en unsigned long (le type des données transmises comme argument à la fonction DIV ()), et 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 pour 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 typecasting.