view release on metacpan or  search on metacpan

lib/Monitoring/Icinga2/Client/REST.pm  view on Meta::CPAN

package Monitoring::Icinga2::Client::REST;

use strict;
use warnings;
use 5.010_001;
use Carp;
use LWP::UserAgent;
use HTTP::Request;
use URI::Escape;
use JSON;
use Encode qw( encode_utf8 );
use Scalar::Util 'looks_like_number';
use version 0.77; our $VERSION = version->declare('2.0.4');

sub new {
    my ($class, $hostname, $port, $path, $version, $insecure) = @_;
    my $cafile;

    defined $hostname
        or croak "hostname argument is required";

    unless( looks_like_number($port) ) {
        # enable hash-style arg passing
        my %args = @_[2..$#_];
        $port = $args{port};
        $path = $args{path};
        $version = $args{version};
        $insecure = $args{insecure};

        if(defined $args{cacert}) {
            # Set ENV variable in case we're using Net::SSL for LWP's HTTPS
            $cafile = $ENV{HTTPS_CA_FILE} = $args{cacert};
        }
    }

    my $self  = bless {
        hostname => $hostname,
        port     => $port // 5665,
        path     => $path // '/',
        version  => $version // 1,
    }, $class;

    $self->{path} .= "/" unless $self->{path} =~ /\/$/;

    $self->{url} = sprintf(
        "https://%s:%d%sv%d",
        @$self{qw/ hostname port path version /}
    );

    $self->{ua} = LWP::UserAgent->new(
        $insecure ? (
            ssl_opts => {
                # Don't verify certs with either SSL module used by LWP
                verify_hostname => 0,
                SSL_verify_callback => sub { 1 },
                # Set ca_file for IO::Socket::SSL
                defined $cafile ? ( SSL_ca_file => $cafile) : (),
            },
        ) : (),
    );

    $self->{ua}->default_header( 'Accept' => 'application/json' );
    $self->{login_status} = "not logged in";

    return $self;
}

sub do_request {
    my ( $self, $method, $uri, $params, $data, $plaintext ) = @_;

    my $request_url = "$self->{url}/$uri";
    $request_url .= '?' . _encode_params($params) if $params;

    my $req = HTTP::Request->new( $method => $request_url );

    if ($data) {
        $data = encode_json($data);
        $req->content($data);
    }

    $self->{res} = $self->{ua}->request($req);

    return unless $self->{res}->is_success;

    # Try with first plaintext if plaintext is set
    if ($plaintext) {
        my $str = encode_utf8( $self->{res}->content );
        if ($str) {
            return $str;
        }
    }

    # Handle non utf8 chars
    my $json_result = decode_json( encode_utf8( $self->{res}->content ) );
    if ($json_result) {
        return $json_result;
    }
    return;
}

sub _encode_params {
    return join '&', map { _encode_param($_) } split /&/, shift;
}

sub _encode_param {
    return join '=', map { uri_escape( $_ ) } split /=/, shift;
}

{
    my %type2keys = (
        CheckCommand => [
            [ qw/ arguments command env vars timeout / ],
            [ qw/ templates zone / ],
        ],
        Downtime => [
            [ qw/ author comment duration end_time entry_time fixed