File Coverage

blib/lib/Zabbix/API.pm

Criterion	Covered	Total	%
statement	26	126	20.6
branch	0	26	0.0
condition	0	2	0.0
subroutine	9	22	40.9
pod	13	13	100.0
total	48	189	25.4

package Zabbix::API;

use strict;
use warnings;
use 5.010;

use Params::Validate qw/:all/;
use Carp qw/carp croak confess cluck/;
use Data::Dumper;
use Scalar::Util qw/weaken/;

use JSON;
use LWP::UserAgent;

our $VERSION = '0.004_TESTING';

sub new {

    my $class = shift;
    my %args = validate(@_, { server => 1,
                              verbosity => 0,
                              env_proxy => 0,
                              lazy => 0 });

    my $self = \%args;

    # defaults
    $self->{verbosity} = 0 unless exists $self->{verbosity};
    $self->{env_proxy} = 0 unless exists $self->{env_proxy};
    $self->{lazy} = 0 unless exists $self->{lazy};

    $self->{stash} = {};

    $self->{ua} = LWP::UserAgent->new(agent => 'Zabbix API client (libwww-perl)',
                                      from => '[e-mail]',
                                      show_progress => $self->{verbosity},
                                      env_proxy => $self->{env_proxy},);

    $self->{cookie} = '';

    bless $self, $class;

    return $self;

}

sub stash {

    ## mutator for stash

    my ($self, $value) = @_;

    if (defined $value) {

        $self->{stash} = $value;
        return $self->{stash};

    } else {

        return $self->{stash};

    }

}

sub verbosity {

    ## mutator for verbosity

    my ($self, $value) = @_;

    if (defined $value) {

        $self->{verbosity} = $value;
        $self->{ua}->{show_progress} = $value;
        return $self->{verbosity};

    } else {

        return $self->{verbosity};

    }

}

sub reference {

    my ($self, $thing) = @_;

    $self->{stash}->{$thing->prefix}->{$thing->id} = $thing;

    return $self;

}

sub dereference {

    my ($self, $thing) = @_;

    delete $self->{stash}->{$thing->prefix}->{$thing->id};

    return $self;

}

sub refof {

    my ($self, $thing) = @_;

    return $self->{stash}->{$thing->prefix}->{$thing->id};

}

sub cookie {

    my $self = shift;

    return $self->{cookie};

}

sub login {

    my $self = shift;

    my %args = validate(@_, { user => 1,
                              password => 1 });

    my $response = $self->raw_query(method => 'user.login',
                                    params => \%args);

    $self->{cookie} = '';

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

    if ($@) {

        # probably could not connect at all
        croak sprintf('Could not connect: %s (%s)', $response->message, $response->code);

    }

    if ($decoded->{error}) {

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

    }

    $self->{cookie} = $decoded->{result};

    $self->{user} = $args{user};

    return $self;

}

sub logout {

    my $self = shift;

    my $decoded = decode_json($self->raw_query(method => 'user.logout')->decoded_content);

    if ($decoded->{error}) {

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

    }

    $self->{cookie} = '';

    delete $self->{user};

    return $self;

}

sub raw_query {

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

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

    # common parameters
    $args{'jsonrpc'} = '2.0';
    $args{'auth'} = $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;

    }

    given ($self->{verbosity}) {

        when (1) {

            print $response->as_string;

        }

        when (2) {

            print Dumper($response);

        }

        default {

        }

    }

    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 'Zabbix server replied: '.$decoded->{error}->{data};

        }

        return $decoded->{result};

    }

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

}

sub api_version {

    my $self = shift;

    my $response = $self->query(method => 'apiinfo.version');

    return $response;

}

sub fetch {

    my $self = shift;
    my $class = shift;

    my %args = validate(@_,
                        { params => { type => HASHREF,
                                      default => {} } });

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

    ## no critic (ProhibitStringyEval)
    eval "require $class";
    ## use critic

    if ($@) {

        my $error = $@;

        croak qq{Could not load class '$class': $error};

    }

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

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

    foreach my $thing (@{$things}) {

        if (my $replacement = $self->refof($thing)) {

            $thing = $replacement;

        } else {

            $self->reference($thing);

        }

    }

    return $things;

}

1;
__END__