I hope python programmers will forgive me, but by now I prefer writing perl :D

So, how can we access excellent Check_MK Livestatus using perl? Well, the first and most obvious (and the most correct, probably) answer is: use the Monitoring::Livestatus perl module.

If you don’t want to go through the procedure of installing modules manually, or configure CPAN, or you have no internet access, or you have your reasons and I may as well stop guessing, you can write some simple code that will allow you to access Livestatus this way:

 ---- 

#!/usr/bin/env perl 

use strict;
use warnings;
use Socket qw/TCP_NODELAY/;
use IO::Socket::UNIX;
use IO::Socket::INET;

# Get the socket name from command line. Assume that the format is one of these:
#    /path/to/livestatus/socket/live
#    HOST:PORT     # e.g. 127.0.0.1:6557
my $peer = shift;
die "Usage: $0 <PEER>\n" unless $peer; 

my $sock;
if ($peer =~ m!/!) {                      # if $peer contains '/' is a path
    $sock = IO::Socket::UNIX->new($peer);
} else {                                  # otherwise assume it's an INET address
    $sock = IO::Socket::INET->new(
        PeerAddr => $peer,
        Type     => SOCK_STREAM,
        Timeout  => 10,
    );
    $sock->sockopt(TCP_NODELAY, 1) if $sock;
}

die "unable to open socket: $!" unless $sock;

# Submit the query; end with an empty line (\n) to tell livestatus
# we want the output
print $sock "GET services
Columns: host_name display_name state state_type
Columns: plugin_output
Filter: state > 0
\n";

# Get and print the result, one line at a time
while (<$sock>) {
    print;
}

# You can let perl handle this for you:
# close($sock);

 ---- 

From the example above you can notice the following:

• You can supply multiple Columns: lines;
• You can print to the socket exactly as you would to a regular filehandle;
• You can read from the socket line by line using the input operator (<>) exactly as you would read from a filehandle;

What you can’t see in the example above is this: when you’re finished reading the query output, Livestatus closes the socket so that no other queries are possible, unless you go again through the
$sock = IO::Socket::*->new() block. That may or may not be a problem, but, in general, you may want to keep the connection open until you decide you’re finished querying Livestatus. This is possible.

By mimicking what is done internally by the Monitoring::Livestatus perl module, we can write a simple module which connects to livestatus and submits the query, then returns its output in a list context and keeps the connection open until we explicitly close() it.

 ---- 

#!/usr/bin/env perl 

package MyLivestatus;
use 5.008008;

use strict;
use warnings;
use Carp qw(croak);
use Socket qw/TCP_NODELAY/;
use IO::Socket::UNIX;
use IO::Socket::INET;

# ------------------------------------------------------------------------------
# Functions:
sub new;
sub query;
sub close;
sub _connect;
sub _disconnect;

# ------------------------------------------------------------------------------
# 'Public' functions:
sub new {
    my ($pkg, $peer) = @_;
    $pkg = ref($pkg) || $pkg;

    my $self = {
        peer => $peer,
    };

    return bless($self, $pkg);
}

sub query {
    my ($self, @query) = @_;
    my $sock = $self->_connect();

    # Append keepalive and header directives to the query:
    push(@query,
        "KeepAlive: on",
        "ResponseHeader: fixed16",
    );

    # Submit the query to livestatus
    {
        # See perlvar -> $LIST_SEPARATOR
        local $" = "\n";
        # See perlvar -> $OUTPUT_RECORD_SEPARATOR
        local $\ = "\n";
        print $sock "@query\n" or croak "unable to submit query: $!";
    }

    # Read the header:
    my $header;
    $sock->read($header, 16) or croak "unable to read from socket: $!";
    chomp($header);
    my ($status, $length) = $header =~ /^(\d{3}) ([0-9 ]{11})/;

    croak "Query failed with status: $status" unless ($status == 200);

    # Remove padding spaces from $length:
    $length =~ s/ //g;

    # Return if query output is empty:
    return unless $length;

    # Read the query result:
    my $result;
    $sock->read($result, $length);

    return split("\n", $result);
}

sub close {
    my ($self) = @_;
    $self->_disconnect();
    return;
}

# ------------------------------------------------------------------------------
# 'Private' functions:
sub _connect {
    my ($self) = @_;

    # Return socket if already connected:
    if ($self->{'sock'}) {
        my $sock = $self->{'sock'};
        return $sock if $sock->connected();
        # Not connected:
        delete $self->{'sock'};
    }

    my $peer = $self->{'peer'};

    my $sock;
    if ($peer =~ m!/!) {                  # if $peer contains '/' is a path
        $sock = IO::Socket::UNIX->new($peer);
    } else {                              # otherwise assume it's an INET address
        $sock = IO::Socket::INET->new(
            PeerAddr => $peer,
            Type     => SOCK_STREAM,
            Timeout  => 10,
        );
        $sock->sockopt(TCP_NODELAY, 1) if $sock;
    }

    croak "Unable to connect to Livestatus: $!" unless $sock;

    $self->{'sock'} = $sock;
    return $sock;
}

sub _disconnect {
    my ($self) = @_;
    return unless $self->{'sock'};
    my $sock = $self->{'sock'};
    if ($sock->connected()) {
        $sock->close();
    }
    delete $self->{'sock'};
    return;
}

# End with a true value or this won't work!
1;

 ---- 

Now save that file as MyLivestatus.pm in the directory you prefer, and use it like this:

 ---- 

#!/usr/bin/env perl 

use strict;
use warnings;
# Assume MyLivestatus.pm is the same directory as this script.
# Adjust this if you need to:
use lib '.';
use MyLivestatus;

my $peer = shift;

die "Usage: $0 <PEER>\n" unless $peer;

my $ls = MyLivestatus->new($peer);

my @query = (
    "GET services",
    "Columns: host_name display_name state state_type",
    "Columns: plugin_output",
    "Filter: state > 0",
);

for ($ls->query(@query)) {
    print "$_\n";
}

$ls->close;

 ---- 

The privous example introduced the following news:

• it puts the query into an array, one query line is one array element; this allows you to better format the query into your code (it can be indented);
• it uses an object-oriented interface; by creating a single MyLivestatus object, you can submit multiple queries using $ls->query() before calling $ls->close() just once, when you’re finished; the module will automatically handle a single connection to the Livetstaus backend. If you call $ls->query() again after $ls->close(), the module just opens a new connection.

EDIT: I added TCP_NODELAY option to the TCP socket in order to prevent TCP stack from buffering the requests (queries to Livestatus). Without the TCP_NODELAY flag, the TCP stack would buffer the request, waiting for some other data to come up before sending the packet, in order to reduce fragmentation. Since we known we want our query to be sent as soon as possible, we force that behavior with the TCP_NODELAY flag (thanks, Simon).