Objets JavaScript supplémentaires

Aperçu

Cette section décrit les ajouts de Zabbix au langage JavaScript implémentés avec Duktape et les fonctions JavaScript globales prises en charge.

Objets intégrés

Zabbix

L'objet Zabbix fournit une interaction avec la fonctionnalité interne de Zabbix.

Exemple :

Zabbix.log(3, "this is a log entry written with 'Warning' log level")

Vous pouvez utiliser les alias suivants :

Exemple (retarder l'exécution de 15 secondes) :

Zabbix.sleep(15000)

HttpRequest

This object encapsulates cURL handle allowing to make simple HTTP requests. Errors are thrown as exceptions.

Example:

try {
           Zabbix.log(4, 'jira webhook script value='+value);
         
           var result = {
               'tags': {
                   'endpoint': 'jira'
               }
           },
           params = JSON.parse(value),
           req = new HttpRequest(),
           fields = {},
           resp;
         
           req.addHeader('Content-Type: application/json');
           req.addHeader('Authorization: Basic '+params.authentication);
         
           fields.summary = params.summary;
           fields.description = params.description;
           fields.project = {"key": params.project_key};
           fields.issuetype = {"id": params.issue_id};
           resp = req.post('https://tsupport.zabbix.lan/rest/api/2/issue/',
               JSON.stringify({"fields": fields})
           );
         
           if (req.getStatus() != 201) {
               throw 'Response code: '+req.getStatus();
           }
         
           resp = JSON.parse(resp);
           result.tags.issue_id = resp.id;
           result.tags.issue_key = resp.key;
       } catch (error) {
           Zabbix.log(4, 'jira issue creation failed json : '+JSON.stringify({"fields": fields}));
           Zabbix.log(4, 'jira issue creation failed : '+error);
         
           result = {};
       }
         
       return JSON.stringify(result);

XML

L'objet XML permet le traitement des données XML dans l'élément et le prétraitement de découverte de bas niveau et les webhooks.

Exemple :

Entrée :

<menu>
           <food type = "breakfast">
               <name>Chocolate</name>
               <price>$5.95</price>
               <description></description>
               <calories>650</calories>
           </food>
       </menu>

Sortie :

{
           "menu": {
               "food": {
                   "@type": "breakfast",
                   "name": "Chocolate",
                   "price": "$5.95",
                   "description": null,
                   "calories": "650"
               }
           }
       }

Règles de sérialisation

La conversion XML vers JSON sera traitée selon les règles suivantes (pour les conversions JSON vers XML, des règles inversées sont appliquées) :

1. Les attributs XML seront convertis en clés dont les noms seront précédés de '@'.

Exemple :

Entrée:

 <xml foo="FOO">
          <bar>
            <baz>BAZ</baz>
          </bar>
        </xml>

Sortie :

 {
          "xml": {
            "@foo": "FOO",
            "bar": {
              "baz": "BAZ"
            }
          }
        }

2. Les éléments à fermeture automatique (<foo/>) seront convertis comme ayant une valeur 'null'.

Exemple :

Entrée:

<xml>
         <foo/>
       </xml>

Sortie :

{
         "xml": {
           "foo": null
         }
       }

3. Les attributs vides (avec la valeur "") seront convertis comme ayant une valeur de chaîne vide ('').

Exemple :

Entrée:

<xml>
         <foo bar="" />
       </xml>

Sortie :

{
         "xml": {
           "foo": {
             "@bar": ""
           }
         }
       }

4. Plusieurs nœuds enfants avec le même nom d'élément seront convertis en une seule clé qui a un tableau de valeurs comme valeur.

Exemple :

Entrée:

<xml>
         <foo>BAR</foo>
         <foo>BAZ</foo>
         <foo>QUX</foo>
       </xml>

Sortie :

{
         "xml": {
           "foo": ["BAR", "BAZ", "QUX"]
         }
       }

5. Si un élément de texte n'a ni attribut ni enfant, il sera converti en chaîne.

Exemple :

Entrée:

<xml>
           <foo>BAZ</foo>
       </xml>

Sortie :

{
         "xml": {
           "foo": "BAZ"
          }
       }

6. Si un élément de texte n'a pas d'enfant, mais possède des attributs : le contenu du texte sera converti en un élément avec la clé '#text' et le contenu comme valeur ; les attributs seront convertis comme décrit dans la règle de sérialisation 1.

Exemple :

Entrée:

<xml>
         <foo bar="BAR">
           BAZ
         </foo>
       </xml>

Sortie :

{
         "xml": {
           "foo": {
             "@bar": "BAR",
             "#text": "BAZ"
           }
         }
       }

Fonctions JavaScript globales

Des fonctions JavaScript globales supplémentaires ont été implémentées avec Duktape :

• btoa(string) - encode la chaîne en chaîne base64
• atob(base64_string) - décode la chaîne base64

try {
           b64 = btoa("utf8 string");
           utf8 = atob(b64);
       } 
       catch (error) {
           return {'error.name' : error.name, 'error.message' : error.message}
       }

• md5(données) - calcule le hachage MD5 d'une chaîne

• sha256(données) - calcule le hachage SHA256 d'une chaîne

• mac('<ype de hachage>',clé,données) - renvoie le hachage HMAC sous forme de chaîne au format hexadécimal ; Les types de hachage MD5 et SHA256 sont pris en charge ; Les paramètres de clé et de données prennent en charge les données binaires. Exemples :

  • hmac('md5',clé,données)
  • hmac('sha256',clé,données)

• sign(hachage,clé,données) - renvoie la signature calculée (signature RSA avec SHA-256) sous forme de chaîne, où :
  hash - seul 'sha256' est autorisé, sinon une erreur est renvoyée ;
  clé - la clé privée. Il doit correspondre à la norme PKCS#1 ou PKCS#8. La clé peut être fournie sous différentes formes :
  

  • avec des espaces au lieu de retours à la ligne ;
  • avec des '' échappés ou non au lieu de nouvelles lignes ;
  • sans aucun retour à la ligne sous la forme d'une chaîne à une seule ligne ;
  • sous forme de chaîne au format JSON.

  La clé peut également être chargée à partir d'une macro utilisateur/macro secrète/coffre.

  data - les données qui seront signées. Il peut s'agir d'une chaîne (les données binaires sont également prises en charge) ou d'un tampon (Uint8Array/ArrayBuffer).
  OpenSSL ou GnuTLS est utilisé pour calculer les signatures. Si Zabbix a été compilé sans aucune de ces bibliothèques de chiffrement, une erreur sera générée ("bibliothèque OpenSSL ou GnuTLS manquante").
  Cette fonction est prise en charge depuis Zabbix 6.0.15.