Origo OS

#!/usr/bin/perl

# All rights reserved and Copyright (c) 2020 Origo Systems ApS.

# This file is provided with no warranty, and is subject to the terms and conditions defined in the license file LICENSE.md.

# The license file is part of this source code package and its content is also available at:

# https://www.origo.io/info/stabiledocs/licensing/stabile-open-source-license

#

# Network and disk activity example:

# https://valve001.irigo.com//stabile/cgi/stats.cgi?uuid=31fe606f-0b5b-46d2-95a3-c38c4678ab0b&cpuload=true&diskactivity=true&networkactivity=true&mem=true&diskspace=true&from=1276425540&to=1277477100

#

# Disk activity example:

# https://valve001.irigo.com//stabile/cgi/stats.cgi?uuid=5eff51c7-f398-4eb9-8495-567cbb2bad77&cpuload=true&diskactivity=true&networkactivity=true&mem=true&diskspace=true&from=1276425540&to=1277477100

#

#

# apt-get install librrdtool-oo-perl

#

use CGI::Carp qw(fatalsToBrowser);

use CGI ':standard';

use JSON;

use URI::Escape;

use RRDTool::OO;

use Tie::DBI;

use ConfigReader::Simple;

my $q = new CGI;

my $params = $q->Vars;

my $suuid = $params->{"uuid"};

die("\nPlease pass a uuid...") unless $suuid;

if ($params->{"format"} eq "text") {

	print("\n");

} else {

    print(header(

                 -type=>"application/json",

                 "Cache-Control"=>"private, max-age=31536000"));

}

my $config = ConfigReader::Simple->new("/etc/stabile/config.cfg", [qw(DBI_USER DBI_PASSWD CPU_OVERCOMMISION)]);

$dbiuser =  $config->get('DBI_USER') || "irigo";

$dbipasswd = $config->get('DBI_PASSWD') || "";

my @uuids;

unless (tie %domreg,'Tie::DBI', {

    db=>'mysql:steamregister',

    table=>'domains',

    key=>'uuid',

    autocommit=>0,

    CLOBBER=>1,

    user=>$dbiuser,

    password=>$dbipasswd}) {print("Stroke=Error Register could not be accessed\n"); exit;};

if ($domreg{$suuid}) { # We are dealing with a server

    push @uuids, $suuid;

} else { # We are dealing with a system

    foreach my $valref (values %domreg) {

        my $sysuuid = $valref->{'system'};

        push @uuids, $valref->{'uuid'} if ($sysuuid eq $suuid)

    }

}

untie %domreg;

unless (@uuids) {

    print "Stroke=Error Invalid uuid\n";

    exit;

}

my $from = $params->{"from"};

my $to = $params->{"to"};

my $dif = $to - $from;

my $now = time();

if (0 && !$params->{'sum'}) {

    my @items;

    foreach my $uuid (@uuids) {

        my $timestamps = ();

        my $cpuLoad = ();

        my $mem = ();

        my $diskActivity = ();

        my $networkActivityRX = ();

        my $networkActivityTX = ();

        my $diskReads = ();

        my $diskWrites = ();

        #print qq|{"uuid": "$uuid"}| unless (hasRRD($uuid));

        next unless hasRRD($uuid);

        #

        # Fetch data from RRD buckets...

        #

        my $rrd = RRDTool::OO->new(file =>"/var/cache/rrdtool/".$uuid."_highres.rrd");

        #$rrd->fetch_start(start => $params->{"from"}, end => $params->{"to"});

        my $last = $rrd->last();

        #$rrd->fetch_start(start => $last-$dif, end => $last);

        $rrd->fetch_start(start => $now-$dif, end=> $now);

        # $rrd->fetch_skip_undef();

        while(my($timestamp, @value) = $rrd->fetch_next()) {

            last if ($timestamp >= $last && $now-$last<20);

            my $domain_cpuTime = shift(@value);

            my $blk_hda_rdBytes = shift(@value);

            my $blk_hda_wrBytes = shift(@value);

            my $if_vnet0_rxBytes = shift(@value);

            my $if_vnet0_txBytes = shift(@value);

            my $domain_nrVirtCpu = shift(@value);

            my $domain_memory = shift(@value);

            my $domain_maxMem = shift(@value);

            push(@$timestamps, $timestamp);

            # domain_cpuTime is avg. nanosecs spent pr. 1s

            # convert to value [0;1]

            $domain_cpuTime = $domain_cpuTime / 10**9 if ($domain_cpuTime);

            push(@$cpuLoad, int(100*$domain_cpuTime)/100);

            #push(@$mem, $domain_memory);

            # push(@$diskActivity, $blk_hda_rdBytes + $blk_hda_wrBytes);

            $blk_hda_rdBytes = $blk_hda_rdBytes if ($blk_hda_rdBytes);

            push(@$diskReads, int(100*$blk_hda_rdBytes)/100);

            $blk_hda_wrBytes = $blk_hda_wrBytes if ($blk_hda_wrBytes);

            push(@$diskWrites, int(100*$blk_hda_wrBytes)/100);

            push(@$networkActivityRX, int(100*$if_vnet0_rxBytes)/100);

            push(@$networkActivityTX, int(100*$if_vnet0_txBytes)/100);

            #

            # Build JSON result...

            #

        }

        my @t = ( $now-$dif, $now);

        my @a = (undef, undef);

        my $item = ();

        $item->{"uuid"} = $uuid;

        $item->{"timestamps"} = $timestamps || \@t;

        if (lc($params->{"cpuload"}) eq "true") {

            $item->{"cpuload"} = $cpuLoad || \@a;

        }

        if (lc($params->{"mem"}) eq "true") {

            $item->{"mem"} = $mem || \@a;

        }

        # if (lc($params->{"diskactivity"}) eq "true") {

        # 	$item->{"diskactivity"} = $diskActivity;

        #   }

        if (lc($params->{"diskReads"}) eq "true") {

            $item->{"diskReads"} = $diskReads || \@a;

          }

        if (lc($params->{"diskWrites"}) eq "true") {

    #        $item->{"diskWrites"} = $diskWrites || \@a;

        }

        if (lc($params->{"networkactivityrx"}) eq "true") {

            $item->{"networkactivityrx"} = $networkActivityRX || \@a;

        }

        if (lc($params->{"networkactivitytx"}) eq "true") {

            $item->{"networkactivitytx"} = $networkActivityTX || \@a;

        }

        push @items, $item;

    }

    print(to_json(\@items, {pretty=>1}));

} else {

    my @items;

    my %cpuLoad = ();

    my %networkActivityRX = ();

    my %networkActivityTX = ();

    my %diskReads = ();

    my %diskWrites = ();

    my $i = 0;

    foreach my $uuid (@uuids) {

        next unless hasRRD($uuid);

        $i++;

        #

        # Fetch data from RRD buckets...

        #

        my $rrd = RRDTool::OO->new(file =>"/var/cache/rrdtool/".$uuid."_highres.rrd");

        my $last = $rrd->last();

        $rrd->fetch_start(start => $now-$dif, end=> $now);

        while(my($timestamp, @value) = $rrd->fetch_next()) {

            last if ($timestamp >= $last && $now-$last<20);

            my $domain_cpuTime = shift(@value);

            my $blk_hda_rdBytes = shift(@value);

            my $blk_hda_wrBytes = shift(@value);

            my $if_vnet0_rxBytes = shift(@value);

            my $if_vnet0_txBytes = shift(@value);

            # domain_cpuTime is avg. nanosecs spent pr. 1s

            # convert to value [0;1]

            $domain_cpuTime = $domain_cpuTime / 10**9 if ($domain_cpuTime);

            $cpuLoad{$timestamp} +=  $domain_cpuTime;

            $blk_hda_rdBytes = $blk_hda_rdBytes if ($blk_hda_rdBytes);

            $diskReads{$timestamp} += $blk_hda_rdBytes;

            $blk_hda_wrBytes = $blk_hda_wrBytes if ($blk_hda_wrBytes);

            $diskWrites{$timestamp} += $blk_hda_wrBytes;

            $networkActivityRX{$timestamp} += $if_vnet0_rxBytes;

            $networkActivityTX{$timestamp} += $if_vnet0_txBytes;

        }

    }

    my @t = ( $now-$dif, $now);

    my @a = (undef, undef);

    $i = $i || 1;

    my $item = ();

    $item->{"uuid"} = $suuid;

    my @tstamps = sort keys %cpuLoad;

    $item->{"timestamps"} = \@tstamps || \@t;

    if (lc($params->{"cpuload"}) eq "true") {

        my @vals;

        foreach(@tstamps) {push @vals, int(100*$cpuLoad{$_})/100 unless ($cpuLoad{$_} > $i)};

        $item->{"cpuload"} = \@vals || \@a;

    }

    if (lc($params->{"diskReads"}) eq "true") {

        my @vals;

        foreach(@tstamps) {push @vals, int(100*$diskReads{$_})/100;};

        $item->{"diskReads"} = \@vals || \@a;

      }

    if (lc($params->{"diskWrites"}) eq "true") {

        my @vals;

        foreach(@tstamps) {push @vals, int(100*$diskWrites{$_})/100;};

        $item->{"diskWrites"} = \@vals || \@a;

    }

    if (lc($params->{"networkactivityrx"}) eq "true") {

        my @vals;

        foreach(@tstamps) {push @vals, int(100*$networkActivityRX{$_})/100;};

        $item->{"networkactivityrx"} = \@vals || \@a;

    }

    if (lc($params->{"networkactivitytx"}) eq "true") {

        my @vals;

        foreach(@tstamps) {push @vals, int(100*$networkActivityTX{$_})/100;};

        $item->{"networkactivitytx"} = \@vals || \@a;

    }

    push @items, $item;

    print(to_json(\@items, {pretty=>1}));

}

#$rrd->graph(

#      image          => "/var/www/orellana.org/stabile/static/img/rrd_out.png",

#      vertical_label => 'Bits',

#      start => $params->{"from"},

##      end            => time(),

#      draw           => { thickness => 1,

#                          dsname    => "domain-cpuTime",

#                          color     => 'FF0000',

#                          legend    => 'Bits over Time',

#                        },

#    ) if (0);

#

# hasRRD: Checks if a RRD for the specified uuid exists.

#

# @param uuid The uuid for which to look for a RRD for

#

sub hasRRD {

	my($uuid) = @_;

	my $rrd_file = "/var/cache/rrdtool/".$uuid."_highres.rrd";

	if ((not -e $rrd_file) and ($uuid)) {

		return(0);

	} else {

		return(1);

	}

}