1 Oggetti JavaScript aggiuntivi

Panoramica

Questa sezione descrive le estensioni di Zabbix al linguaggio JavaScript implementato con Duktape e le funzioni JavaScript globali supportate.

Oggetti incorporati

Zabbix

L'oggetto Zabbix consente l'interazione con le funzionalità interne di Zabbix.

Esempio:

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

È possibile utilizzare i seguenti alias:

Esempio (ritarda l'esecuzione di 15 secondi):

Zabbix.sleep(15000)

HttpRequest

Questo oggetto incapsula un handle cURL che consente di effettuare semplici richieste HTTP. Gli errori vengono generati come eccezioni.

Esempio:

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://jira.example.com/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'oggetto XML consente l'elaborazione dei dati XML nel preprocessing di item e low-level discovery e nei webhook.

Esempio:

Input:

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

Output:

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

Regole di serializzazione

La conversione da XML a JSON verrà elaborata secondo le seguenti regole (per le conversioni da JSON a XML si applicano le regole inverse):

1. Gli attributi XML verranno convertiti in chiavi con i loro nomi preceduti da '@'.

Esempio:

Input:

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

Output:

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

2. Gli elementi autochiudenti (<foo/>) verranno convertiti come aventi valore 'null'.

Esempio:

Input:

<xml>
  <foo/>
</xml>

Output:

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

3. Gli attributi vuoti (con valore "") verranno convertiti come aventi valore stringa vuota ('').

Esempio:

Input:

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

Output:

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

4. Più nodi figli con lo stesso nome di elemento verranno convertiti in un'unica chiave che avrà come valore un array di valori.

Esempio:

Input:

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

Output:

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

5. Se un elemento di testo non ha attributi né figli, verrà convertito come stringa.

Esempio:

Input:

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

Output:

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

6. Se un elemento di testo non ha figli ma ha attributi, il contenuto testuale verrà convertito in un elemento con la chiave '#text' e il contenuto come valore; gli attributi verranno convertiti come descritto nella regola di serializzazione 1.

Esempio:

Input:

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

Output:

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

Funzioni JavaScript globali

Con Duktape sono state implementate ulteriori funzioni JavaScript globali:

• btoa(data) - codifica i dati in una stringa base64.
• atob(base64_string) - decodifica una stringa base64 come buffer Uint8Array.

try {
    b64 = btoa("test string");
    buffer = atob(b64);

    // Note that decoding logic depends on the data format of the buffer.
    decoded = String.fromCharCode.apply(this, [].slice.call(buffer));
} 
catch (error) {
    return {'error.name' : error.name, 'error.message' : error.message};
}

• md5(data) - calcola l'hash MD5 dei dati.
• sha256(data) - calcola l'hash SHA256 dei dati.

• hmac('<hash type>',key,data) - restituisce un hash HMAC come stringa in formato esadecimale; md5 e sha256 sono supportati come hash type; i parametri key e data supportano dati binari.

  Esempi:

  • hmac('md5',key,data)
  • hmac('sha256',key,data)

• sign(hash,key,data) - restituisce la firma calcolata (firma RSA con SHA-256) come stringa, dove:
  hash - è consentito solo sha256, altrimenti viene generato un errore.
  key - la chiave privata. Deve essere conforme allo standard PKCS#1 o PKCS#8. La chiave può essere fornita in diverse forme:
  

  • con spazi al posto delle nuove righe
  • con \n con escape o senza escape al posto delle nuove righe
  • senza alcuna nuova riga, come stringa su una sola riga
  • come stringa in formato JSON

  La chiave può anche essere caricata da una macro utente/macro segreta/vault.

  data - i dati che verranno firmati. Possono essere una stringa (sono supportati anche dati binari) o un buffer (Uint8Array/ArrayBuffer).

  Esempio:

  • sign('sha256',key,data)

  OpenSSL o GnuTLS vengono utilizzati per calcolare le firme. Se Zabbix è stato compilato senza una di queste librerie di crittografia, verrà generato un errore ('missing OpenSSL or GnuTLS library').