Objetos JavaScript extras

Visão geral

Esta seção descreve as adições à linguagem JavaScript implementadas com Duktape e funções JavaScript globais suportadas.

Objetos Built-in

Zabbix

O objeto Zabbix fornece interação com a funcionalidade interna do Zabbix.

Exemplo:

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

Você pode usar os seguintes aliases:

Exemplo (atrasar a execução por 15 segundos):

Zabbix.sleep(15000)

Requisição Http

Este objeto encapsula o manipulador cURL, permitindo realizar requisições HTTP simples. Erros são lançados como exceções.

Exemplo:

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

O objeto XML permite o processamento de dados em formato XML em itens, pré-processamento de descoberta de baixo nível e webhooks.

Exemplo:

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

Regras de serialização

A conversão de XML para JSON será processada de acordo com as seguintes regras (para conversões de JSON para XML, as regras inversas se aplicam):

1. Atributos XML serão convertidos em chaves com seus nomes precedidos de '@'.

Exemplo:

Input:

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

Output:

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

2. Elementos auto-fechados (<foo/>) serão convertidos como tendo valor 'null'.

Exemplo:

Input:

<xml>
         <foo/>
       </xml>

Output:

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

3. Atributos vazios (com valor "") serão convertidos como tendo valor de string vazia ('').

Exemplo:

Input:

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

Output:

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

4. Múltiplos nodes filhos com o mesmo nome de elemento serão convertidos em uma única chave com um array de valores como seu valor.

Exemplo:

Input:

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

Output:

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

5. Se um elemento de texto não tiver atributos e nem filhos, ele será convertido como uma string.

Exemplo:

Input:

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

Output:

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

6. Se um elemento de texto não tiver filhos, mas tiver atributos, o conteúdo de texto será convertido em um elemento com a chave '#text' e o conteúdo como valor; os atributos serão convertidos conforme descrito na regra 1.

Exemplo:

Input:

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

Output:

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

Funções globais de JavaScript

Funções globais adicionais de JavaScript foram implementadas com Duktape:

• btoa(data) - codifica os dados em uma string Base64
• atob(base64_string) - decodifica uma string Base64

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

• md5(data) - calcula o hash MD5 dos dados

• sha256(data) - calcula o hash SHA256 dos dados

• hmac('<hash type>',key,data) - retorna o hash HMAC como uma string formatada em hexadecimal;

• Os tipos de hash MD5 e SHA256 são suportados; Os parâmetros key e data aceitam dados binários. Exemplos:

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

• sign(hash,key,data) - retorna a assinatura calculada (assinatura RSA com SHA-256) como uma string, onde:
  hash - apenas 'sha256' é permitido, caso contrário, um erro será lançado;
  key - a chave privada, que deve seguir o padrão PKCS#1 ou PKCS#8. A chave pode ser fornecida em diferentes formatos:
  

  • com espaços em vez de quebras de linha;
  • com '' escapados ou não escapados no lugar de quebras de linha;
  • sem quebras de linha, como uma string de linha única;
  • como uma string formatada em JSON.

  A chave também pode ser carregada a partir de um macro de usuário, macro secreta ou cofre.

  data - os dados que serão assinados. Pode ser uma string (dados binários também são suportados) ou um buffer (Uint8Array/ArrayBuffer).
  OpenSSL ou GnuTLS é usado para calcular as assinaturas. Caso o Zabbix tenha sido compilado sem essas bibliotecas de criptografia, um erro será lançado ('missing OpenSSL or GnuTLS library').
  Essa função é suportada desde o Zabbix 6.0.15.