1 Objetos JavaScript adicionais

Visão geral

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

Objetos internos

Zabbix

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

Exemplo:

Zabbix.log(3, "esta é uma entrada de log gravada com o nível de log 'Warning'")

Você pode usar os seguintes aliases:

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

Zabbix.sleep(15000)

HttpRequest

Este objeto encapsula o identificador do cURL, permitindo realizar solicitações HTTP simples. Os 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 XML no pré-processamento de item e descoberta de baixo nível e webhooks.

Exemplo:

Entrada:

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

Saída:

{
    "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 invertidas são aplicadas):

1. Os atributos XML serão convertidos em chaves que têm seus nomes precedidos por '@'.

Exemplo:

Entrada:

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

Saída:

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

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

Exemplo:

Entrada:

<xml>
  <foo/>
</xml>

Saída:

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

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

Exemplo:

Entrada:

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

Saída:

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

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

Exemplo:

Entrada:

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

Saída:

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

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

Exemplo:

Entrada:

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

Saída:

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

6. Se um elemento de texto não tiver filhos, mas tiver atributos, o conteúdo do 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 de serialização 1.

Exemplo:

Entrada:

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

Saída:

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

Funções globais do JavaScript

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

• btoa(data) - codifica os dados em uma string base64.
• atob(base64_string) - decodifica a string base64 como um buffer Uint8Array.

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

    // Observe que a lógica de decodificação depende do formato dos dados do buffer.
    decoded = String.fromCharCode.apply(this, [].slice.call(buffer));
} 
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 um hash HMAC como uma string formatada em hexadecimal; md5 e sha256 são suportados como hash type; os parâmetros key e data suportam 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. Deve corresponder ao padrão PKCS#1 ou PKCS#8. A chave pode ser fornecida em diferentes formas:
  

  • com espaços em vez de quebras de linha
  • com \n escapado ou não escapado em vez 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 uma macro de usuário/macro secreta/vault.

  data - os dados que serão assinados. Pode ser uma string (dados binários também são suportados) ou buffer (Uint8Array/ArrayBuffer).

  Exemplo:

  • sign('sha256',key,data)

  OpenSSL ou GnuTLS é usado para calcular as assinaturas. Se o Zabbix foi compilado sem nenhuma dessas bibliotecas de criptografia, um erro será lançado ('missing OpenSSL or GnuTLS library').