File Coverage

blib/lib/Zabbix/Tiny.pm

Criterion	Covered	Total	%
statement	118	125	94.4
branch	33	40	82.5
condition	2	5	40.0
subroutine	15	15	100.0
pod	2	6	33.3
total	170	191	89.0

package Zabbix::Tiny;
use strict;
use warnings;
use Moo;
use Carp;
use LWP;
use JSON;
use version;

our $VERSION = "2.0.1";

has 'server' => (
    is       => 'rw',
    required => 1,
);
has 'user' => (
    is       => 'rw',
    required => 1,
);
has 'password' => (
    is       => 'rw',
    required => 1,
);
has 'zabbix_method'   => ( is => 'ro' );
has 'zabbix_params'   => ( is => 'ro' );
has 'auth'            => ( is => 'ro' );
has 'ua'              => (
    is      => 'ro',
    lazy    => 1,
    default => sub { LWP::UserAgent->new },
);
has 'id'              => ( is => 'ro', default => sub { 1 } );
has 'post_response'   => ( is => 'ro' );
has 'last_response'   => ( is => 'ro' );
has 'json_request'    => ( is => 'ro' );
has 'json_response'   => ( is => 'ro' );
has 'verify_hostname' => ( is => 'rw', default => sub { 1 } );
has 'ssl_opts'        => ( is => 'rw' );
has 'delay'           => ( is => 'rw' );
has 'request'         => ( is => 'ro' );
has 'json_prepared'   => ( is => 'ro' );
has 'json_executed'   => ( is => 'ro', default => sub { 0 } );
has 'redo'            => ( is => 'ro' );
has 'version'         => ( is => 'lazy' );

my @content_type = ( 'content-type', 'application/json', );

sub BUILD {
    my $self      = shift;
    my $ua        = $self->ua;
    my $url       = $self->server;

    my $json_data = {
        jsonrpc => '2.0',
        id      => $self->id,
        method  => 'user.login',
        params  => {
            user     => $self->user,
            password => $self->password,
        },
    };

    if ( $self->verify_hostname == 0 ) {
        $ua->ssl_opts( verify_hostname => 0 );
    }

    if ( $self->ssl_opts ) {
        $ua->ssl_opts( %{ $self->{ssl_opts} } );
    }
}


sub _build_version {
    my $self      = shift;
    my $id        = $self->id;
    my $ua        = $self->ua;
    my $url       = $self->server;

    my $json_data = {
        jsonrpc => '2.0',
        id      => $self->id,
        method  => 'apiinfo.version',
        params  => {
        },
    };

    my $encoded_json = encode_json ($json_data);

    my $post_response = $ua->post(
        $self->server,
        @content_type,
        Content => $encoded_json
    );

    _validate_http_response($post_response);

    my $response_content = decode_json( $post_response->{_content} );

    if ( $response_content->{error} ) {
        my $error = $response_content->{error}->{data};
        croak("Error: $error");
    }
    else {
        my $version = version->new($response_content->{'result'});
        return($version);
    }
}


sub login {
    my $self      = shift;
    my $id        = $self->id;
    my $ua        = $self->ua;
    my $url       = $self->server;

    my $json_data =  {
        jsonrpc => '2.0',
        id      => $id,
        method  => 'user.login',
    };

    if ( $self->version lt "6.0" ) {
        $json_data->{params} = {
            user     => $self->user,
            password => $self->password,
        };
    } else {
        $json_data->{params} = {
            username => $self->user,
            password => $self->password,
        };
    }

    my $json = encode_json($json_data);
    my $response = $ua->post( $url, @content_type, Content => $json );

    _validate_http_response($response);

    my $content = decode_json( $response->{_content} ) or die($!);

    if ( $content->{error} ) {
        my $error_data = $content->{error}->{data};
        my $error_msg  = $content->{error}->{message};
        my $error_code = $content->{error}->{code};
        my $error = "Error from Zabbix (code $error_code): $error_msg  $error_data";
        croak($error);
    }

    $self->{auth} = $content->{'result'};
}


sub _validate_http_response {
    my $response = shift;

    if ( $response->{_rc} !~ /2\d\d/ ) {
        my $error_message = "HTTP error ";
        $error_message   .= "(code $response->{_rc}) ";
        $error_message   .= $response->{_msg} // q{};
        croak($error_message);
    }
}

sub prepare {
    my $self   = shift;
    my $method = shift;
    $self->{ id }++;
    if ($method) {
        $self->{zabbix_method} = $method;
        undef $self->{zabbix_params};
        my @args = @_;
        if ( scalar @args == 1 ) {
            $self->{zabbix_params} = $args[0];
        }
        else {
            my %params = @args;
            $self->{zabbix_params} = \%params;
        }
    }
    unless ($self->{zabbix_method} eq 'apiinfo.version') {
        login($self) if ( !$self->auth );
    }
    if ( !$self->zabbix_method ) {
        croak("No Zabbix API method defined");
    }
    $self->{request} = {
        jsonrpc => '2.0',
        id      => $self->id,
        method  => $self->zabbix_method,
        params  => $self->zabbix_params,
    };
    unless ($self->{zabbix_method} eq 'apiinfo.version') {
        $self->{request}->{auth} = $self->auth;
    }
    $self->{json_prepared} = encode_json( $self->request ) or die($!);
}

sub execute {
    my $self = shift;
    my $ua   = $self->ua;
    $self->{post_response} = $ua->post( $self->server, @content_type,
        Content => $self->json_prepared );
    $self->{json_request}  = $self->{post_response}->{'_request'}->{_content};
    $self->{json_response} = $self->post_response->{_content};
    if ( $self->post_response->{_content} eq q{} ) {
        croak( "Empty response received from the Zabbix API. This can indicate an error on the API side like running out of memory." );
    }
    $self->{last_response} = decode_json( $self->{post_response}->{_content} );
    my $method = $self->zabbix_method;
    my $params = $self->zabbix_params;
    prepare($self); ## Rerun prepare to get the new request id.
}

sub do {
    my $self   = shift;
    my $method = shift;
    my @args   = @_;
    if ($method) {
        prepare( $self, $method, @args );
    }
    execute($self);
    if ( $self->{last_response}->{error} ) {
        my $error = $self->{last_response}->{error}->{data};
        if (   ( !$self->{redo} )
            && ( $error eq 'Session terminated, re-login, please.' ) )
        {
            $self->{redo}++;
            delete( $self->{auth} );
            prepare($self);
            &do($self);    ## Need to use "&" because "do" is a perl keyword.
        }
        else {
            croak("Error: $error");
        }
    }
    else {
        delete( $self->{redo} ) if $self->redo;
        $self->{json_executed} = 1;
        return $self->{last_response}->{'result'};
    }
}

sub DEMOLISH {
    my $self      = shift;
    my $method    = shift;
    my $ua        = $self->ua;
    my $auth      = $self->auth;
    my $url       = $self->server;

    return unless ($ua);

    my $json_data = {
        jsonrpc => '2.0',
        id      => ++$self->{ id },
        method  => 'user.logout',
        auth    => $auth,
    };
    my $json = encode_json($json_data);
    $self->{post_response} = $ua->post( $url, @content_type, Content => $json );
}

1;

__END__