File Coverage

blib/lib/Zabbix2/API.pm

Criterion	Covered	Total	%
statement	36	120	30.0
branch	0	34	0.0
condition			n/a
subroutine	12	21	57.1
pod	7	7	100.0
total	55	182	30.2

package Zabbix2::API;

use strict;
use warnings;
use 5.010;
use Carp;

use Moo;

use Scalar::Util qw/blessed/;
use Module::Loaded;
use Module::Load;
use Params::Validate qw/validate :types/;
use JSON;
use LWP::UserAgent;
use Log::Any;

our $VERSION = '0.013';

has 'server' => (is => 'ro',
                 required => 1);
has 'ua' => (is => 'ro',
             lazy => 1,
             builder => '_build_ua');
has 'cookie' => (is => 'ro',
                 predicate => 1,
                 clearer => '_clear_cookie',
                 writer => '_set_cookie');
has 'user' => (is => 'ro',
               init_arg => undef,
               clearer => '_clear_user',
               writer => '_set_user');
# equivalent to the old "lazy" parameter
has 'pull_after_push_mode' => (is => 'rw',
                               default => 1);

state $global_id = int(rand(10000));

sub _build_ua {
    my $self = shift;
    return LWP::UserAgent->new(agent => 'Zabbix API client (libwww-perl)');
}

sub useragent {
    return shift->ua;
}

sub api_version {
    my $self = shift;
    # can't use _raw_query here because the server refuses the request
    # if an auth parameter is present -- wtf zabbix
    my $response = eval { $self->ua->post($self->server,
                                          'Content-Type' => 'application/json-rpc',
                                          Content => encode_json({
                                              jsonrpc => '2.0',
                                              id => $global_id++,
                                              method => 'apiinfo.version',
                                                                 })) };

    if (my $error = $@) {
        # no good
        croak sprintf('Could not request API version info: %s (%s, %s)',
                      $error, $response->code, $response->message);
    }

    my $decoded = eval { decode_json($response->decoded_content) };

    if (my $error = $@) {
        # no good either
        croak sprintf('Could not request API version info: %s (%s, %s)',
                      $error, $response->code, $response->message);
    }

    if ($decoded->{error}) {
        croak 'Could not request API version info: '.$decoded->{error}->{data};
    }

    return $decoded->{result};
}

sub login {
    my $self = shift;
    my %args = validate(@_, { user => 1,
                              password => 1 });
    $self->_clear_cookie;
    $self->_clear_user;

    my $response = $self->_raw_query(method => 'user.login',
                                     params => \%args);
    my $decoded = eval { decode_json($response->decoded_content) };

    if (my $error = $@) {
        # probably could not connect at all
        croak sprintf('Could not connect: %s (%s, %s)',
                      $error, $response->code, $response->message);
    }

    if ($decoded->{error}) {
        croak 'Could not log in: '.$decoded->{error}->{data};
    }

    $self->_set_cookie($decoded->{result});
    $self->_set_user($args{user});

    return $self;
}

sub logout {

    my $self = shift;
    my $response = $self->_raw_query(method => 'user.logout');
    my $decoded = eval { decode_json($response->decoded_content) };

    if (my $error = $@) {
        # probably could not connect at all
        croak sprintf('Could not log out: %s (%s, %s)',
                      $error, $response->code, $response->message);
    }

    if ($decoded->{error}) {
        croak 'Could not log out: '.$decoded->{error}->{data};
    }

    $self->_clear_cookie;
    $self->_clear_user;

    return $self;
}

sub _raw_query {
    my ($self, %args) = @_;

    # common parameters
    $args{'jsonrpc'} = '2.0';
    $args{'auth'} = $self->cookie if $self->cookie;
    $args{'id'} = $global_id++;

    my $response = eval { $self->ua->post($self->server,
                                          'Content-Type' => 'application/json-rpc',
                                          Content => encode_json(\%args)) };

    if (my $error = $@) {
        confess $error;
    }

    Log::Any->get_logger->trace($response->request->as_string);
    Log::Any->get_logger->debug($response->as_string);

    return $response;
}

sub query {
    my $self = shift;
    my %args = validate(@_, { method => { TYPE => SCALAR },
                              params => { TYPE => HASHREF,
                                          optional => 1 }});

    my $response = $self->_raw_query(%args);

    if ($response->is_success) {
        my $decoded = decode_json($response->decoded_content);
        if ($decoded->{error}) {
            croak(sprintf('While calling method %s, Zabbix server replied: %s',
                          $args{method},
                          $decoded->{error}->{data}));
        }
        return $decoded->{result};
    }

    croak 'Received HTTP error: '.$response->decoded_content;
}

sub fetch {
    my $self = shift;
    my $class = shift;
    my %args = validate(@_,
                        { params => { type => HASHREF,
                                      default => {} } });

    $class =~ s/^(?:Zabbix2::API::)?/Zabbix2::API::/;

    unless (Module::Loaded::is_loaded($class)) {
        eval { Module::Load::load($class) };
        if (my $error = $@) {
            croak qq{Could not load class '$class': $error};
        }
        $class->can('new')
            or croak "Class '$class' does not implement required 'new' method";
        $class->can('_prefix')
            or croak "Class '$class' does not implement required '_prefix' method";
        $class->can('_extension')
            or croak "Class '$class' does not implement required '_extension' method";
    }

    my $response = $self->query(method => $class->_prefix('.get'),
                                params => {
                                    %{$args{params}},
                                    $class->_extension
                                });

    return [ map { $class->new(root => $self, data => $_)  } @{$response} ];
}

sub fetch_single {
    my ($self, $class, %args) = @_;

    my $results = $self->fetch($class, %args);
    my $result_count = scalar @{$results};

    if ($result_count > 1) {
        croak qq{Too many results for 'fetch_single': expected 0 or 1, got $result_count};
    }

    return $results->[0];
}

1;
__END__