1 Додатни JavaScript објекти

Преглед

Ова секција описује Zabbix додатке JavaScript језику који су имплементирани са Duktape-ом и подржане глобалне JavaScript функције.

Уграђени објекти

Zabbix

Објекат Zabbix обезбеђује интеракцију са интерном функционалношћу.

Пример:

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

Можете користити следеће псеудониме:

Пример (одлагање извршавања за 15 секунди):

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://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

XML објекат омогућава обраду XML података у ставци и претходну обраду откривања ниског нивоа и вебхукове.

Пример:

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"
       }
       }
       }

Serialization rules

XML to JSON conversion will be processed according to the following rules (for JSON to XML conversions reversed rules are applied):

1. XML attributes will be converted to keys that have their names prepended with '@'.

Example:

Input:

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

Output:

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

2. Self-closing elements (<foo/>) will be converted as having 'null' value.

Example:

Input:

<xml>
         <foo/>
       </xml>

Output:

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

3. Empty attributes (with "" value) will be converted as having empty string ('') value.

Example:

Input:

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

Output:

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

4. Multiple child nodes with the same element name will be converted to a single key that has an array of values as its value.

Example:

Input:

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

Output:

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

5. If a text element has no attributes and no children, it will be converted as a string.

Example:

Input:

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

Output:

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

6. If a text element has no children but has attributes, text content will be converted to an element with the key '#text' and content as a value; attributes will be converted as described in the serialization rule 1.

Example:

Input:

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

Output:

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

Global JavaScript functions

Additional global JavaScript functions have been implemented with Duktape:

• btoa(data) - encodes the data to base64 string
• atob(base64_string) - decodes base64 string

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

• md5(data) - calculates the MD5 hash of the data

• sha256(data) - calculates the SHA256 hash of the data

• hmac('<hash type>',key,data) - returns HMAC hash as hex formatted string; MD5 and SHA256 hash types are supported; key and data parameters support binary data. Examples:

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

• sign(hash,key,data) - returns calculated signature (RSA signature with SHA-256) as a string, where:
  hash - only 'sha256' is allowed, otherwise an error is thrown;
  key - the private key. It should correspond to PKCS#1 or PKCS#8 standard. The key can be provided in different forms:
  

  • with spaces instead of newlines;
  • with escaped or non-escaped ''s instead of newlines;
  • without any newlines as a single-line string;
  • as a JSON-formatted string.

  The key also can be loaded from a user macro/secret macro/vault.

  data - the data that will be signed. It can be a string (binary data also supported) or buffer (Uint8Array/ArrayBuffer).
  OpenSSL or GnuTLS is used to calculate the signatures. If Zabbix was built without any of these encryption libraries, an error will be thrown ('missing OpenSSL or GnuTLS library').