OSRF Nagios Service Check

#!/usr/bin/perl

use strict;
use warnings;
use Getopt::Long;
use OpenSRF::System;
use OpenSRF::AppSession;
use OpenSRF::Utils::JSON;
use OpenSRF::EX qw(:try);

my $opt_osrf_config = '/openils/conf/opensrf_core.xml';
my @services;
my @routers;

GetOptions(
    'osrf-config=s' => \$opt_osrf_config,
);

try {
    OpenSRF::System->bootstrap_client(config_file => $opt_osrf_config);
} otherwise {
    print "Bootstrap failed\n";
    exit 2;
};

sub prep_service_list {
    my $session = OpenSRF::AppSession->create('opensrf.settings');
    try {
        $session->connect;
    } otherwise {
        print "Settings Connect Failed\n";
        exit 2;
    };
    my $req = $session->request('opensrf.settings.xpath.get', '//activeapps/appname');
    my $list = $req->recv;

    if(UNIVERSAL::isa($list,"Error")) {
        print "Active Apps List Failed\n";
        exit 2;
    }

    $req->finish;
    my %u_list = map { ($_ => 1) } @{$list->content};
    @services = keys(%u_list);

    $session->finish;
    $session->disconnect;
}

sub prep_routers_list {
    my $config = OpenSRF::Utils::Config->current;
    foreach(@{$config->bootstrap->routers}) {
        my $router = {};
        $router->{name} = $_->{name};
        $router->{domain} = $_->{domain};
        $router->{services} = \@services unless $_->{services};
        $router->{services} = $_->{services}->{service} if $_->{services};
        push @routers, $router;
    }
}

sub check_routers {
    my $conf = OpenSRF::Utils::Config->current;
    foreach my $router (@routers) {
        $conf->bootstrap->router_name($router->{name});
        $conf->bootstrap->domain($router->{domain});
        my $failed = 1;
        # First, check the router to see what it claims to have active services-wise
        my $session = OpenSRF::AppSession->create('router');
        try {
            $failed = 0 if $session->connect;
        } otherwise {
            $failed = 1;
        };
        if($session->state != $session->CONNECTED || $failed) {
            $router->{online} = 0;
            next;
        }
        my $req = $session->request('opensrf.router.info.class.list');
        my $class_list = $req->recv;
        $req->finish;

        if(UNIVERSAL::isa($class_list,"Error")) {
            $session->finish;
            $session->disconnect;
            $router->{online} = 0;
            next;
        }
        $router->{online} = 1;
        $router->{checked} = 0;
        $router->{pass} = 0;
        $router->{failed} = [];
        my %online_services = map { ($_ => 1) } @{$class_list->content};
        foreach my $service (@{$router->{services}}) {
            next unless grep { $service eq $_ } @services; # Skip services we aren't trying to run
            my $passed = 0;
            $router->{checked} += 1;
            if($online_services{$service}) {
                my $session2 = OpenSRF::AppSession->create($service);
                try {
                    $session2->connect;
                };
                if($session2->state == $session2->CONNECTED) {
                    my $req2 = $session2->request('opensrf.system.echo.atomic','Test');
                    my $testresult = $req2->recv;
                    $req2->finish;
                    $session2->finish;
                    $session2->disconnect;
                    $passed = 1 if @{$testresult->content}[0] eq 'Test';
                }
            }
            if($passed) {
                $router->{pass} += 1;
            } else {
                push @{$router->{failed}}, $service;
            }
        }
        $session->finish;
        $session->disconnect;
    }
}

sub output_result {
    my $checked_services = 0;
    my $up_services = 0;
    my @down_services;
    my @down_routers;
    my $retcode = 0;
    foreach my $router (@routers) {
        if(!$router->{online}) {
            push @down_routers, $router->{domain};
            next;
        }
        $checked_services += $router->{checked};
        $up_services += $router->{pass};
        foreach (@{$router->{failed}}) {
            push @down_services, $router->{domain} . ':' . $_;
        }
    }
    if(@down_routers) {
        print "Router(s) Offline: " . join(', ', @down_routers) . "\n";
        $retcode = 2;
    } elsif ($checked_services != $up_services) {
        print "Service(s) not responding\n";
        $retcode = 2;
    } else {
        print "Routers/Services OK\n";
    }
    print "$_\n" foreach (@down_services);
    exit $retcode;
}

# CHEAT - We need SettingsClient to have cached stuff
try {
    OpenSRF::Utils::SettingsClient->new()->config_value('none');
} otherwise {
    print "Settings Fetch Failed\n";
    exit 2;
};
prep_service_list();
prep_routers_list();
check_routers();
output_result();