reports/rrdgraphing/graph.pl

#!/usr/bin/perl -w

# 
# i-scream central monitoring system
# http://www.i-scream.org
# Copyright (C) 2000-2002 i-scream
# 
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
# 
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
# 
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
#

# -----------------------------------------------------------
# i-scream graph generation script
# http://www.i-scream.org
#
# Generates graphs from rrd databases for i-scream data.
#
# $Author: tdb $
# $Id: graph.pl,v 1.15 2005/02/10 17:35:58 tdb Exp $
#------------------------------------------------------------

## TODO
# possibly make more configurable?
#  -- allow configurable periods of graphs
#  -- comments, types, etc

my($version) = '$Id: graph.pl,v 1.15 2005/02/10 17:35:58 tdb Exp $';

$| = 1;

use strict;
use Getopt::Std;
use RRDs;

# define variables that will be read from the config
# nb. keep this insync with the config file!
use vars qw{
    $imgdir $rrddir
    $maxrrdage $maximgage $deleterrds $deleteimgs
    $hex_slash $hex_underscore $hex_space $hex_colon $hex_bslash
    $rrdstep $retry_wait
    $verbose $quiet
};

# default locate of the config file
my($configfile) = "rrdgraphing.conf";

# check for command line arguments
my(%opts);
my($ret) = getopts('hvqVc:', \%opts);

# if invalid argument given, $ret will not be 1
&usage() if $ret != 1;

# first process the arguments which might mean we exit now

# -h is usage
if($opts{h}) {
    &usage();
}
# -V is version
if($opts{V}) {
    print "graph.pl version: $version\n";
    exit(1);
}

# Then try getting the config

# -c specifies the config file location
if($opts{c}) {
    $configfile = $opts{c};
}
# suck in the config
&log("reading config from $configfile\n");
do $configfile;

# Then any options we might want to override the config with

# -v is verbose
if($opts{v}) {
    $verbose = $opts{v};
}
# -q is verbose
if($opts{q}) {
    $quiet = $opts{q};
    # if we're meant to be quiet, we can hardly be verbose!
    $verbose = 0;
}

# Read the contents of the base directory
# and pull out the list of subdirectories (except . and .. :)
opendir(DIR, $rrddir);
my(@rrddirlist) = sort grep { -d "$rrddir/$_" && !/^\.$/ && !/^\.\.$/ } readdir(DIR);
closedir DIR;

# look through each directory, as they might
# contain rrds for a particular machine
foreach my $machine (@rrddirlist) {
    # Read the contents of the directory
    opendir(DIR, "$rrddir/$machine");
    my(@rrdlist) = grep { /\.rrd$/ && -f "$rrddir/$machine/$_" } readdir(DIR);
    closedir DIR;
    
    # See what rrd we have, and generate the graphs accordingly
    foreach my $rrd (@rrdlist) {
        chomp $rrd;
        # stat the file
        my($dev,$ino,$mode,$nlink,$uid,$gid,$rdev,$size,$atime,$mtime,
         $ctime,$blksize,$blocks) = stat("$rrddir/$machine/$rrd");
        # check if it's old enough to be deleted
        if((time - $mtime) > $maxrrdage) {
            # do we delete the rrd, or just ignore it?
            if($deleterrds) {
                # if so, delete it
                unlink("$rrddir/$machine/$rrd");
                &log("deleted old rrd $rrddir/$machine/$rrd\n");
            }
            else {
                &log("ignored old rrd $rrddir/$machine/$rrd\n");
            }
            # no more processing required for this rrd
            next;
        }
        if($rrd =~ /^(cpu)\.rrd$/) {
            my(@data);
            my(@rawdata);
            push @data, "AREA:$1:swap:swap#FF00FF:OK:swap cpu  ";
            push @data, "STACK:$1:iowait:iowait#FF0000:OK:iowait cpu";
            push @data, "STACK:$1:kernel:kernel#00FFFF:OK:kernel cpu";
            push @data, "STACK:$1:user:user#0000FF:OK:user cpu  ";
            push @data, "LINE2:$1:idle:idle#00FF00:OK:idle cpu  ";
            push @rawdata, "--upper-limit=100";
            &makegraph($machine, $1, "CPU Usage for $machine", "% cpu time", \@data, \@rawdata);
        }
        if($rrd =~ /^(uptime)\.rrd$/) {
            my(@data);
            push @data, "LINE2:$1:uptime:uptime#0000FF:OK:uptime";
            &makegraph($machine, $1, "Uptime for $machine", "uptime in seconds", \@data);
        }
        if($rrd =~ /^(mem)\.rrd$/) {
            my(@data);
            my(@rawdata);
            # we don't actually want to display free or total memory,
            # although we need it to work out peruse...
            push @data, "NONE:$1:free:free#CCCCFF:NONE:free memory";
            push @data, "NONE:$1:total:total#0000FF:NONE:total memory\\n";
            push @data, "NONE:$1:cache:cache#0000FF:NONE:cache memory\\n";
            # calculate peruse - note that we only use 'free' if it's
            # less or equal to total (this is to avoid negative percentages :)
            push @rawdata, "CDEF:peruse=total,free,total,LE,free,0,IF,-,total,/,100,*";
            push @rawdata, "CDEF:percacuse=cache,total,LE,cache,0,IF,total,/,100,*";
            # and add it to the graph
            push @rawdata, "AREA:peruse#CCCCFF:% memory in use";
            &addlegend(\@rawdata, "peruse");
            push @rawdata, "LINE2:percacuse#0000FF:% memory cache ";
            &addlegend(\@rawdata, "percacuse");
            push @rawdata, "--upper-limit=100";
            push @rawdata, "--base=1024";
            # put the total memory on the graph so we can map percentages to real values
            push @rawdata, "GPRINT:total:LAST:Current total memory\\: \%.2lf %sb\\c";
            &makegraph($machine, $1, "Memory Usage for $machine", "% memory in use", \@data, \@rawdata);
        }
        if($rrd =~ /^(load)\.rrd$/) {
            my(@data);
            push @data, "LINE2:$1:load1:load1#CCCCFF:OK: 1 min load average";
            push @data, "LINE2:$1:load5:load5#7777FF:OK: 5 min load average";
            push @data, "LINE2:$1:load15:load15#0000FF:OK:15 min load average";
            &makegraph($machine, $1, "Loads for $machine", "load average", \@data);
        }
        if($rrd =~ /^(proc)\.rrd$/) {
            my(@data);
            push @data, "AREA:$1:stopped:stopped#00FFFF:OK:stopped processes ";
            push @data, "STACK:$1:zombie:zombie#FF0000:OK:zombie processes  ";
            push @data, "STACK:$1:cpu:cpu#00FF00:OK:cpu processes     ";
            push @data, "STACK:$1:sleeping:sleeping#0000FF:OK:sleeping processes";
            push @data, "LINE2:$1:total:total#FF00FF:OK:total processes   ";
            &makegraph($machine, $1, "Processes on $machine", "no. of processes", \@data);
        }
        if($rrd =~ /^(swap)\.rrd$/) {
            my(@data);
            my(@rawdata);
            # we don't actually want to display free or total swap,
            # although we need it to work out peruse...
            push @data, "NONE:$1:free:free#CCCCFF:NONE:free swap";
            push @data, "NONE:$1:total:total#0000FF:NONE:total swap\\n";
            # calculate peruse - note that we only use 'free' if it's
            # less or equal to total (this is to avoid negative percentages :)
            push @rawdata, "CDEF:peruse=total,free,total,LE,free,0,IF,-,total,/,100,*";
            # and add it to the graph
            push @rawdata, "AREA:peruse#CCCCFF:% swap in use";
            push @rawdata, "--upper-limit=100";
            push @rawdata, "--base=1024";
            # add some nice values to the legend
            &addlegend(\@rawdata, "peruse");
            # put the total swap on the graph so we can map percentages to real values
            push @rawdata, "GPRINT:total:LAST:Current total swap\\: \%.2lf %sb\\c";
            &makegraph($machine, $1, "Swap Usage for $machine", "% swap in use", \@data, \@rawdata);
        }
        if($rrd =~ /^(users)\.rrd$/) {
            my(@data);
            push @data, "AREA:$1:count:count#CCCCFF:OK:user count";
            &makegraph($machine, $1, "User Count for $machine", "no. of users", \@data);
        }
        if($rrd =~ /^(paging)\.rrd$/) {
            my(@data);
            push @data, "AREA:$1:pageins:pageins#00FF00:OK:pages paged in ";
            push @data, "LINE2:$1:pageouts:pageouts#0000FF:OK:pages paged out";
            &makegraph($machine, $1, "Paging on $machine", "pages per second", \@data);
        }
        if($rrd =~ /^(disk)-(\S+)\.rrd$/) {
            my(@data);
            my(@rawdata);
            # we need this lot for our calculations, but we'll never show them
            push @data, "NONE:$1-$2:total:total#0000FF:NONE:total size\\n";
            push @data, "NONE:$1-$2:used:used#CCCCFF:NONE:used space";
            push @data, "NONE:$1-$2:totalinodes:totalinodes#000000:NONE:total inodes";
            push @data, "NONE:$1-$2:freeinodes:freeinodes#000000:NONE:free inodes";
            # calculate peruse, add it to the graph, and add a legend
            push @rawdata, "CDEF:peruse=used,total,/,100,*";
            push @rawdata, "AREA:peruse#CCCCFF:% disk used  ";
            &addlegend(\@rawdata, "peruse");
            # put the total space on the graph so we can map percentages to real values
            push @rawdata, "GPRINT:total:LAST:Current total space\\: \%.2lf %sb\\c";
            # calculate perinodeuse, add it to the graph, and add a legend
            push @rawdata, "CDEF:perinodeuse=totalinodes,freeinodes,totalinodes,LT,freeinodes,0,IF,-,totalinodes,/,100,*";
            push @rawdata, "LINE2:perinodeuse#FF4444:% inodes used";
            push @rawdata, "--upper-limit=100";
            push @rawdata, "--base=1024";
            &addlegend(\@rawdata, "perinodeuse");
            # put the total inodes on the graph so we can map percentages to real values
            push @rawdata, "GPRINT:totalinodes:LAST:Current total inodes\\: \%.2lf %s\\c";
            # some name tidting
            my($type) = $1;
            my($name) = $2;
            my($nicename) = $2;
            $nicename =~ s/$hex_slash/\//g;
            $nicename =~ s/$hex_underscore/_/g;
            $nicename =~ s/$hex_bslash/\\/g;
            $nicename =~ s/$hex_space/ /g;
            $nicename =~ s/$hex_colon/:/g;
            &makegraph($machine, "$type-$name", "Disk Usage for $machine on $nicename", "% usage", \@data, \@rawdata);
        }
        if($rrd =~ /^(diskio)-(\S+)\.rrd$/) {
            my(@data);
            my(@rawdata);
            push @data, "AREA:$1-$2:rbytes:rbytes#00FF00:OK:read bytes ";
            push @data, "LINE2:$1-$2:wbytes:wbytes#0000FF:OK:write bytes";
            push @rawdata, "--base=1024";
            # some name tidting
            my($type) = $1;
            my($name) = $2;
            my($nicename) = $2;
            $nicename =~ s/$hex_slash/\//g;
            $nicename =~ s/$hex_underscore/_/g;
            $nicename =~ s/$hex_bslash/\\/g;
            $nicename =~ s/$hex_space/ /g;
            $nicename =~ s/$hex_colon/:/g;
            &makegraph($machine, "$type-$name", "Disk IO for $machine on $nicename", "bytes per second", \@data, \@rawdata);
        }
        if($rrd =~ /^(net)-(\S+)\.rrd$/) {
            my(@data);
            my(@rawdata);
            push @data, "AREA:$1-$2:rx:rx#00FF00:OK:received bytes  ";
            push @data, "LINE2:$1-$2:tx:tx#0000FF:OK:transfered bytes";
            push @rawdata, "--base=1024";
            # some name tidting
            my($type) = $1;
            my($name) = $2;
            my($nicename) = $2;
            $nicename =~ s/$hex_slash/\//g;
            $nicename =~ s/$hex_underscore/_/g;
            $nicename =~ s/$hex_bslash/\\/g;
            $nicename =~ s/$hex_space/ /g;
            $nicename =~ s/$hex_colon/:/g;
            &makegraph($machine, "$type-$name", "Network IO for $machine on $nicename", "bytes per second", \@data, \@rawdata);
        }
        if($rrd =~ /^(mailq)-(\S+)\.rrd$/) {
            my(@data);
            my(@rawdata);
            push @data, "LINE2:$1-$2:size:size#0000FF:OK:messages";
            &makegraph($machine, "$1-$2", "Mail Queue ($2) Size for $machine", "messages in queue", \@data, \@rawdata);
        }
        # probably a queue with a name like this :)
        if($rrd =~ /^(\d+)_0\.rrd$/) {
            my(@data);
            my(@rawdata);
            my($baserrd) = $1;
            my($i) = 0;
            while( -f "$rrddir/$machine/$baserrd\_$i.rrd" ) {
                push @data, "LINE2:$baserrd\_$i:size:size$i" . &get_colour($i) . ":OK:queue$i size ";
                ++$i;
            }
            push @data, "LINE2:$baserrd\_0:total:total#FF0000:OK:packets/sec ";
            my($comment);
            if(-f "$rrddir/$machine/$baserrd.def") {
                open(DEF, "$rrddir/$machine/$baserrd.def");
                $comment = <DEF>;
                chomp $comment if defined $comment;
            }
            $comment = "unknown queue" if not defined $comment;
            &makegraph($machine, $baserrd, $comment, "", \@data, \@rawdata);
        }
    }
    # have a last check, maybe we can remove the directory now?
    # (only if we're deleting stuff)
    if($deleterrds) {
        # Read the contents of the directory
        opendir(DIR, "$rrddir/$machine");
        my(@dirlist) = grep { !/^\.$/ && !/^\.\.$/ } readdir(DIR);
        closedir DIR;
        if($#dirlist == -1) {
            rmdir "$rrddir/$machine";
            &log("deleting empty rrd directory $rrddir/$machine\n");
        }
    }
}

if($deleteimgs) {
    # Read the contents of the graphs directory
    # and pull out the list of subdirectories (except . and .. :)
    opendir(DIR, $imgdir);
    my(@imgdirlist) = sort grep { -d "$imgdir/$_" && !/^\.$/ && !/^\.\.$/ } readdir(DIR);
    closedir DIR;

    # look through each directory, as they might
    # contain images for a particular machine
    foreach my $machine (@imgdirlist) {
        # Read the contents of the directory
        opendir(DIR, "$imgdir/$machine");
        my(@imglist) = grep { /\.png$/ && -f "$imgdir/$machine/$_" } readdir(DIR);
        closedir DIR;

        # See what rrd we have, and generate the graphs accordingly
        foreach my $img (@imglist) {
            chomp $img;
            # stat the img
            my($dev,$ino,$mode,$nlink,$uid,$gid,$rdev,$size,$atime,$mtime,
             $ctime,$blksize,$blocks) = stat("$imgdir/$machine/$img");
            # check if it's old enough to be deleted
            if((time - $mtime) > $maximgage) {
                # if so, delete it
                unlink("$imgdir/$machine/$img");
                &log("deleted old image $imgdir/$machine/$img\n");
            }
        }
        # have a last check, maybe we can remove the directory now?
        # Read the contents of the directory
        opendir(DIR, "$imgdir/$machine");
        my(@dirlist) = grep { !/^\.$/ && !/^\.\.$/ } readdir(DIR);
        closedir DIR;
        if($#dirlist == -1) {
            rmdir "$imgdir/$machine";
            &log("deleted empty image directory $imgdir/$machine\n");
        }
    }
}

exit(0);


#
# subroutine to make some graphs
#
# $machine   = name of the machine
#              (eg. kernow.ukc.ac.uk)
# $type      = the type of graph for the machine
#              (eg. cpu)
# $title     = the title for the graph
#              (eg. kernow CPU usage)
# $vlabel    = the vertical label to apply to the left side of the graph
#              (eg. kb/s)
# $dataref   = a reference to an array containing information for the graph
#              elements of format: "gtype:rrdname:dsname:name#colour:legend:comment with spaces"
#              (if gtype is "NONE" only a DEF of 'name' will be defined, no line will be plotted)
#              (if legend is "NONE" the latest/average/max/min legend won't be printed)
# $rawcmdref = a reference to an array containing raw rrd commands
#              elements a single command each, no spaces
#

sub makegraph() {
    my($machine, $type, $title, $vlabel, $dataref, $rawcmdref) = @_;
    # pass in these arrays by reference
    my(@data) = @$dataref if defined $dataref;
    my(@rawcmd) = @$rawcmdref if defined $rawcmdref;
    # check if directory exists for images
    if(! -d "$imgdir/$machine") {
        # not sure on this umask, but it seems to work?
        mkdir "$imgdir/$machine", 0777;
        &log("created directory $imgdir/$machine\n");
    }
    my(@rrdcmd);
    foreach my $dataitem (@data) {
        # dataitem should be: "gtype:rrdname:dsname:name#colour:legend:comment with spaces"
        # (if gtype is "NONE" only a DEF of 'name' will be defined, no line will be plotted)
        # (if legend is "NONE" the latest/average/max/min legend won't be printed)
        if($dataitem =~ /^(\S+):(\S+):(\S+):(\S+)#(.{6}):(\S+):(.*)$/) {
            push @rrdcmd, "DEF:$4=$rrddir/$machine/$2.rrd:$3:AVERAGE";
            if($1 ne "NONE") {
                push @rrdcmd, "$1:$4#$5:$7";
                if($6 ne "NONE") {
                    # add some nice values to the legend
                    &addlegend(\@rrdcmd, $4);
                }
            }
        }
    }
    push @rrdcmd, "--title=$title";
    push @rrdcmd, "--imgformat=PNG";
    push @rrdcmd, "--lower-limit=0";
    push @rrdcmd, "--vertical-label=$vlabel";
    # not entirely convinced this is good...
    push @rrdcmd, "--alt-autoscale-max";
    # add any further raw commands
    push @rrdcmd, @rawcmd;
    RRDs::graph ("$imgdir/$machine/$type-3h.png", "--start=-10800", @rrdcmd);
    my($err_3h) = RRDs::error;
    &log("created $imgdir/$machine/$type-3h.png\n") unless $err_3h;
    &error("Error generating 3h graph for $machine/$type: $err_3h\n") if $err_3h;
    RRDs::graph ("$imgdir/$machine/$type-1d.png", "--start=-86400", @rrdcmd);
    my($err_1d) = RRDs::error;
    &log("created $imgdir/$machine/$type-1d.png\n") unless $err_1d;
    &error("Error generating 1d graph for $machine/$type: $err_1d\n") if $err_1d;
    RRDs::graph ("$imgdir/$machine/$type-1w.png", "--start=-604800", @rrdcmd);
    my($err_1w) = RRDs::error;
    &log("created $imgdir/$machine/$type-1w.png\n") unless $err_1w;
    &error("Error generating 1w graph for $machine/$type: $err_1w\n") if $err_1w;
    RRDs::graph ("$imgdir/$machine/$type-1m.png", "--start=-2678400", @rrdcmd);
    my($err_1m) = RRDs::error;
    &log("created $imgdir/$machine/$type-1m.png\n") unless $err_1m;
    &error("Error generating 1m graph for $machine/$type: $err_1m\n") if $err_1m;
    RRDs::graph ("$imgdir/$machine/$type-1y.png", "--start=-31536000", @rrdcmd);
    my($err_1y) = RRDs::error;
    &log("created $imgdir/$machine/$type-1y.png\n") unless $err_1y;
    &error("Error generating 1y graph for $machine/$type: $err_1y\n") if $err_1y;
    return;
}

# subroutine to add a legend
# accepts reference to an array and a name
sub addlegend() {
    my($dataref, $name) = @_;
    push @$dataref, "GPRINT:$name:LAST:Current\\: \%8.2lf %s";
    push @$dataref, "GPRINT:$name:AVERAGE:Average\\: \%8.2lf %s";
    push @$dataref, "GPRINT:$name:MAX:Max\\: \%8.2lf %s\\n";
}

# hacky subroutine to return a colour
# could be done much better somehow :/
sub get_colour {
    my($col) = @_;
    if($col == 0) {
        return "#0000FF";
    }
    elsif($col == 1) {
        return "#00FF00";
    }
    elsif($col == 2) {
        return "#FF00FF";
    }
    elsif($col == 3) {
        return "#FFFF00";
    }
    elsif($col == 4) {
        return "#00FFFF";
    }
    else {
        return "#000066";
    }
}

# prints out usage information then exits
sub usage() {
    print "Usage: graph.pl [options]\n";
    print "Options\n";
    print "  -c config        Specifies the configuration file\n";
    print "                    default: rrdgraphing.conf\n";
    print "  -v               Be verbose about what's happening\n";
    print "  -q               Be quiet, even supress errors\n";
    print "  -V               Print version number\n"; 
    print "  -h               Prints this help page\n";
    exit(1);
}       

# prints a log message if verbose is turned on
sub log() {
    my($msg) = @_;
    print $msg if $verbose;
}

# prints an error message unless quiet is turned on
sub error() {
    my($msg) = @_;
    print STDERR $msg unless $quiet;
}
Revision:	1.16
Committed:	Thu Mar 31 20:49:33 2005 UTC (19 years, 5 months ago) by tdb
Content type:	text/plain
Branch:	MAIN
Changes since 1.15:	+9 -9 lines
Log Message:	Fix problem when free == total, which resulted in graphs being drawn at 100% when they should be 0%. Pointed out by skel.
#	User	Rev	Content
1	tdb	1.1	#!/usr/bin/perl -w
2
3	tdb	1.2	#
4			# i-scream central monitoring system
5	tdb	1.14	# http://www.i-scream.org
6	tdb	1.2	# Copyright (C) 2000-2002 i-scream
7			#
8			# This program is free software; you can redistribute it and/or
9			# modify it under the terms of the GNU General Public License
10			# as published by the Free Software Foundation; either version 2
11			# of the License, or (at your option) any later version.
12			#
13			# This program is distributed in the hope that it will be useful,
14			# but WITHOUT ANY WARRANTY; without even the implied warranty of
15			# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16			# GNU General Public License for more details.
17			#
18			# You should have received a copy of the GNU General Public License
19			# along with this program; if not, write to the Free Software
20			# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
21			#
22
23	tdb	1.1	# -----------------------------------------------------------
24			# i-scream graph generation script
25	tdb	1.14	# http://www.i-scream.org
26	tdb	1.1	#
27			# Generates graphs from rrd databases for i-scream data.
28			#
29			# $Author: tdb $
30	tdb	1.16	# $Id: graph.pl,v 1.15 2005/02/10 17:35:58 tdb Exp $
31	tdb	1.1	#------------------------------------------------------------
32
33			## TODO
34			# possibly make more configurable?
35			# -- allow configurable periods of graphs
36			# -- comments, types, etc
37	tdb	1.5
38	tdb	1.16	my($version) = '$Id: graph.pl,v 1.15 2005/02/10 17:35:58 tdb Exp $';
39	tdb	1.1
40			$\| = 1;
41	tdb	1.5
42	tdb	1.1	use strict;
43	tdb	1.5	use Getopt::Std;
44	tdb	1.1	use RRDs;
45
46	tdb	1.5	# define variables that will be read from the config
47			# nb. keep this insync with the config file!
48	tdb	1.15	use vars qw{
49			$imgdir $rrddir
50	tdb	1.5	$maxrrdage $maximgage $deleterrds $deleteimgs
51	tdb	1.15	$hex_slash $hex_underscore $hex_space $hex_colon $hex_bslash
52	tdb	1.5	$rrdstep $retry_wait
53			$verbose $quiet
54			};
55
56			# default locate of the config file
57			my($configfile) = "rrdgraphing.conf";
58
59			# check for command line arguments
60			my(%opts);
61			my($ret) = getopts('hvqVc:', \%opts);
62
63			# if invalid argument given, $ret will not be 1
64			&usage() if $ret != 1;
65
66			# first process the arguments which might mean we exit now
67
68			# -h is usage
69			if($opts{h}) {
70			&usage();
71			}
72			# -V is version
73			if($opts{V}) {
74			print "graph.pl version: $version\n";
75			exit(1);
76			}
77
78			# Then try getting the config
79
80			# -c specifies the config file location
81			if($opts{c}) {
82			$configfile = $opts{c};
83			}
84			# suck in the config
85			&log("reading config from $configfile\n");
86			do $configfile;
87
88			# Then any options we might want to override the config with
89
90			# -v is verbose
91			if($opts{v}) {
92			$verbose = $opts{v};
93			}
94			# -q is verbose
95			if($opts{q}) {
96			$quiet = $opts{q};
97			# if we're meant to be quiet, we can hardly be verbose!
98			$verbose = 0;
99			}
100
101	tdb	1.1	# Read the contents of the base directory
102			# and pull out the list of subdirectories (except . and .. :)
103			opendir(DIR, $rrddir);
104	tdb	1.13	my(@rrddirlist) = sort grep { -d "$rrddir/$_" && !/^\.$/ && !/^\.\.$/ } readdir(DIR);
105	tdb	1.1	closedir DIR;
106
107	tdb	1.13	# look through each directory, as they might
108	tdb	1.1	# contain rrds for a particular machine
109			foreach my $machine (@rrddirlist) {
110			# Read the contents of the directory
111			opendir(DIR, "$rrddir/$machine");
112			my(@rrdlist) = grep { /\.rrd$/ && -f "$rrddir/$machine/$_" } readdir(DIR);
113			closedir DIR;
114
115			# See what rrd we have, and generate the graphs accordingly
116			foreach my $rrd (@rrdlist) {
117			chomp $rrd;
118	tdb	1.3	# stat the file
119			my($dev,$ino,$mode,$nlink,$uid,$gid,$rdev,$size,$atime,$mtime,
120			$ctime,$blksize,$blocks) = stat("$rrddir/$machine/$rrd");
121			# check if it's old enough to be deleted
122			if((time - $mtime) > $maxrrdage) {
123	tdb	1.4	# do we delete the rrd, or just ignore it?
124			if($deleterrds) {
125			# if so, delete it
126			unlink("$rrddir/$machine/$rrd");
127	tdb	1.5	&log("deleted old rrd $rrddir/$machine/$rrd\n");
128			}
129			else {
130			&log("ignored old rrd $rrddir/$machine/$rrd\n");
131	tdb	1.4	}
132	tdb	1.3	# no more processing required for this rrd
133			next;
134			}
135	tdb	1.1	if($rrd =~ /^(cpu)\.rrd$/) {
136			my(@data);
137			my(@rawdata);
138	tdb	1.13	push @data, "AREA:$1:swap:swap#FF00FF:OK:swap cpu ";
139			push @data, "STACK:$1:iowait:iowait#FF0000:OK:iowait cpu";
140			push @data, "STACK:$1:kernel:kernel#00FFFF:OK:kernel cpu";
141			push @data, "STACK:$1:user:user#0000FF:OK:user cpu ";
142	tdb	1.15	push @data, "LINE2:$1:idle:idle#00FF00:OK:idle cpu ";
143	tdb	1.1	push @rawdata, "--upper-limit=100";
144	tdb	1.10	&makegraph($machine, $1, "CPU Usage for $machine", "% cpu time", \@data, \@rawdata);
145	tdb	1.1	}
146	tdb	1.15	if($rrd =~ /^(uptime)\.rrd$/) {
147			my(@data);
148			push @data, "LINE2:$1:uptime:uptime#0000FF:OK:uptime";
149			&makegraph($machine, $1, "Uptime for $machine", "uptime in seconds", \@data);
150			}
151	tdb	1.1	if($rrd =~ /^(mem)\.rrd$/) {
152			my(@data);
153			my(@rawdata);
154	tdb	1.11	# we don't actually want to display free or total memory,
155			# although we need it to work out peruse...
156	tdb	1.7	push @data, "NONE:$1:free:free#CCCCFF:NONE:free memory";
157	tdb	1.11	push @data, "NONE:$1:total:total#0000FF:NONE:total memory\\n";
158	tdb	1.13	push @data, "NONE:$1:cache:cache#0000FF:NONE:cache memory\\n";
159	tdb	1.16	# calculate peruse - note that we only use 'free' if it's
160			# less or equal to total (this is to avoid negative percentages :)
161			push @rawdata, "CDEF:peruse=total,free,total,LE,free,0,IF,-,total,/,100,*";
162			push @rawdata, "CDEF:percacuse=cache,total,LE,cache,0,IF,total,/,100,*";
163	tdb	1.1	# and add it to the graph
164	tdb	1.11	push @rawdata, "AREA:peruse#CCCCFF:% memory in use";
165	tdb	1.13	&addlegend(\@rawdata, "peruse");
166			push @rawdata, "LINE2:percacuse#0000FF:% memory cache ";
167			&addlegend(\@rawdata, "percacuse");
168	tdb	1.11	push @rawdata, "--upper-limit=100";
169	tdb	1.12	push @rawdata, "--base=1024";
170	tdb	1.11	# put the total memory on the graph so we can map percentages to real values
171	tdb	1.12	push @rawdata, "GPRINT:total:LAST:Current total memory\\: \%.2lf %sb\\c";
172	tdb	1.11	&makegraph($machine, $1, "Memory Usage for $machine", "% memory in use", \@data, \@rawdata);
173	tdb	1.1	}
174			if($rrd =~ /^(load)\.rrd$/) {
175			my(@data);
176	tdb	1.8	push @data, "LINE2:$1:load1:load1#CCCCFF:OK: 1 min load average";
177			push @data, "LINE2:$1:load5:load5#7777FF:OK: 5 min load average";
178			push @data, "LINE2:$1:load15:load15#0000FF:OK:15 min load average";
179	tdb	1.10	&makegraph($machine, $1, "Loads for $machine", "load average", \@data);
180	tdb	1.1	}
181			if($rrd =~ /^(proc)\.rrd$/) {
182			my(@data);
183	tdb	1.13	push @data, "AREA:$1:stopped:stopped#00FFFF:OK:stopped processes ";
184			push @data, "STACK:$1:zombie:zombie#FF0000:OK:zombie processes ";
185			push @data, "STACK:$1:cpu:cpu#00FF00:OK:cpu processes ";
186			push @data, "STACK:$1:sleeping:sleeping#0000FF:OK:sleeping processes";
187	tdb	1.15	push @data, "LINE2:$1:total:total#FF00FF:OK:total processes ";
188	tdb	1.10	&makegraph($machine, $1, "Processes on $machine", "no. of processes", \@data);
189	tdb	1.1	}
190			if($rrd =~ /^(swap)\.rrd$/) {
191			my(@data);
192			my(@rawdata);
193	tdb	1.11	# we don't actually want to display free or total swap,
194			# although we need it to work out peruse...
195	tdb	1.7	push @data, "NONE:$1:free:free#CCCCFF:NONE:free swap";
196	tdb	1.11	push @data, "NONE:$1:total:total#0000FF:NONE:total swap\\n";
197	tdb	1.16	# calculate peruse - note that we only use 'free' if it's
198			# less or equal to total (this is to avoid negative percentages :)
199			push @rawdata, "CDEF:peruse=total,free,total,LE,free,0,IF,-,total,/,100,*";
200	tdb	1.1	# and add it to the graph
201	tdb	1.11	push @rawdata, "AREA:peruse#CCCCFF:% swap in use";
202			push @rawdata, "--upper-limit=100";
203	tdb	1.12	push @rawdata, "--base=1024";
204	tdb	1.7	# add some nice values to the legend
205	tdb	1.11	&addlegend(\@rawdata, "peruse");
206			# put the total swap on the graph so we can map percentages to real values
207	tdb	1.12	push @rawdata, "GPRINT:total:LAST:Current total swap\\: \%.2lf %sb\\c";
208	tdb	1.11	&makegraph($machine, $1, "Swap Usage for $machine", "% swap in use", \@data, \@rawdata);
209	tdb	1.1	}
210			if($rrd =~ /^(users)\.rrd$/) {
211			my(@data);
212	tdb	1.7	push @data, "AREA:$1:count:count#CCCCFF:OK:user count";
213	tdb	1.10	&makegraph($machine, $1, "User Count for $machine", "no. of users", \@data);
214	tdb	1.1	}
215	tdb	1.11	if($rrd =~ /^(paging)\.rrd$/) {
216			my(@data);
217	tdb	1.13	push @data, "AREA:$1:pageins:pageins#00FF00:OK:pages paged in ";
218	tdb	1.12	push @data, "LINE2:$1:pageouts:pageouts#0000FF:OK:pages paged out";
219	tdb	1.11	&makegraph($machine, $1, "Paging on $machine", "pages per second", \@data);
220			}
221	tdb	1.12	if($rrd =~ /^(disk)-(\S+)\.rrd$/) {
222	tdb	1.1	my(@data);
223			my(@rawdata);
224	tdb	1.11	# we need this lot for our calculations, but we'll never show them
225	tdb	1.12	push @data, "NONE:$1-$2:total:total#0000FF:NONE:total size\\n";
226	tdb	1.11	push @data, "NONE:$1-$2:used:used#CCCCFF:NONE:used space";
227			push @data, "NONE:$1-$2:totalinodes:totalinodes#000000:NONE:total inodes";
228			push @data, "NONE:$1-$2:freeinodes:freeinodes#000000:NONE:free inodes";
229			# calculate peruse, add it to the graph, and add a legend
230	tdb	1.12	push @rawdata, "CDEF:peruse=used,total,/,100,*";
231	tdb	1.11	push @rawdata, "AREA:peruse#CCCCFF:% disk used ";
232			&addlegend(\@rawdata, "peruse");
233			# put the total space on the graph so we can map percentages to real values
234	tdb	1.12	push @rawdata, "GPRINT:total:LAST:Current total space\\: \%.2lf %sb\\c";
235	tdb	1.11	# calculate perinodeuse, add it to the graph, and add a legend
236			push @rawdata, "CDEF:perinodeuse=totalinodes,freeinodes,totalinodes,LT,freeinodes,0,IF,-,totalinodes,/,100,*";
237			push @rawdata, "LINE2:perinodeuse#FF4444:% inodes used";
238			push @rawdata, "--upper-limit=100";
239	tdb	1.12	push @rawdata, "--base=1024";
240	tdb	1.11	&addlegend(\@rawdata, "perinodeuse");
241			# put the total inodes on the graph so we can map percentages to real values
242			push @rawdata, "GPRINT:totalinodes:LAST:Current total inodes\\: \%.2lf %s\\c";
243			# some name tidting
244	tdb	1.1	my($type) = $1;
245			my($name) = $2;
246			my($nicename) = $2;
247			$nicename =~ s/$hex_slash/\//g;
248			$nicename =~ s/$hex_underscore/_/g;
249	tdb	1.15	$nicename =~ s/$hex_bslash/\\/g;
250			$nicename =~ s/$hex_space/ /g;
251			$nicename =~ s/$hex_colon/:/g;
252	tdb	1.11	&makegraph($machine, "$type-$name", "Disk Usage for $machine on $nicename", "% usage", \@data, \@rawdata);
253	tdb	1.1	}
254	tdb	1.12	if($rrd =~ /^(diskio)-(\S+)\.rrd$/) {
255			my(@data);
256			my(@rawdata);
257	tdb	1.13	push @data, "AREA:$1-$2:rbytes:rbytes#00FF00:OK:read bytes ";
258	tdb	1.12	push @data, "LINE2:$1-$2:wbytes:wbytes#0000FF:OK:write bytes";
259			push @rawdata, "--base=1024";
260	tdb	1.15	# some name tidting
261			my($type) = $1;
262			my($name) = $2;
263			my($nicename) = $2;
264			$nicename =~ s/$hex_slash/\//g;
265			$nicename =~ s/$hex_underscore/_/g;
266			$nicename =~ s/$hex_bslash/\\/g;
267			$nicename =~ s/$hex_space/ /g;
268			$nicename =~ s/$hex_colon/:/g;
269			&makegraph($machine, "$type-$name", "Disk IO for $machine on $nicename", "bytes per second", \@data, \@rawdata);
270	tdb	1.12	}
271			if($rrd =~ /^(net)-(\S+)\.rrd$/) {
272			my(@data);
273			my(@rawdata);
274	tdb	1.13	push @data, "AREA:$1-$2:rx:rx#00FF00:OK:received bytes ";
275	tdb	1.12	push @data, "LINE2:$1-$2:tx:tx#0000FF:OK:transfered bytes";
276			push @rawdata, "--base=1024";
277	tdb	1.15	# some name tidting
278			my($type) = $1;
279			my($name) = $2;
280			my($nicename) = $2;
281			$nicename =~ s/$hex_slash/\//g;
282			$nicename =~ s/$hex_underscore/_/g;
283			$nicename =~ s/$hex_bslash/\\/g;
284			$nicename =~ s/$hex_space/ /g;
285			$nicename =~ s/$hex_colon/:/g;
286			&makegraph($machine, "$type-$name", "Network IO for $machine on $nicename", "bytes per second", \@data, \@rawdata);
287	tdb	1.12	}
288	tdb	1.13	if($rrd =~ /^(mailq)-(\S+)\.rrd$/) {
289			my(@data);
290			my(@rawdata);
291			push @data, "LINE2:$1-$2:size:size#0000FF:OK:messages";
292			&makegraph($machine, "$1-$2", "Mail Queue ($2) Size for $machine", "messages in queue", \@data, \@rawdata);
293			}
294	tdb	1.1	# probably a queue with a name like this :)
295			if($rrd =~ /^(\d+)_0\.rrd$/) {
296			my(@data);
297			my(@rawdata);
298			my($baserrd) = $1;
299			my($i) = 0;
300			while( -f "$rrddir/$machine/$baserrd\_$i.rrd" ) {
301	tdb	1.7	push @data, "LINE2:$baserrd\_$i:size:size$i" . &get_colour($i) . ":OK:queue$i size ";
302	tdb	1.1	++$i;
303			}
304	tdb	1.9	push @data, "LINE2:$baserrd\_0:total:total#FF0000:OK:packets/sec ";
305	tdb	1.1	my($comment);
306			if(-f "$rrddir/$machine/$baserrd.def") {
307			open(DEF, "$rrddir/$machine/$baserrd.def");
308			$comment = <DEF>;
309			chomp $comment if defined $comment;
310			}
311			$comment = "unknown queue" if not defined $comment;
312	tdb	1.10	&makegraph($machine, $baserrd, $comment, "", \@data, \@rawdata);
313	tdb	1.1	}
314	tdb	1.3	}
315			# have a last check, maybe we can remove the directory now?
316	tdb	1.4	# (only if we're deleting stuff)
317			if($deleterrds) {
318			# Read the contents of the directory
319			opendir(DIR, "$rrddir/$machine");
320			my(@dirlist) = grep { !/^\.$/ && !/^\.\.$/ } readdir(DIR);
321			closedir DIR;
322			if($#dirlist == -1) {
323			rmdir "$rrddir/$machine";
324	tdb	1.5	&log("deleting empty rrd directory $rrddir/$machine\n");
325	tdb	1.4	}
326	tdb	1.3	}
327			}
328
329	tdb	1.4	if($deleteimgs) {
330			# Read the contents of the graphs directory
331			# and pull out the list of subdirectories (except . and .. :)
332			opendir(DIR, $imgdir);
333	tdb	1.13	my(@imgdirlist) = sort grep { -d "$imgdir/$_" && !/^\.$/ && !/^\.\.$/ } readdir(DIR);
334	tdb	1.3	closedir DIR;
335
336	tdb	1.15	# look through each directory, as they might
337	tdb	1.4	# contain images for a particular machine
338			foreach my $machine (@imgdirlist) {
339			# Read the contents of the directory
340			opendir(DIR, "$imgdir/$machine");
341			my(@imglist) = grep { /\.png$/ && -f "$imgdir/$machine/$_" } readdir(DIR);
342			closedir DIR;
343
344			# See what rrd we have, and generate the graphs accordingly
345			foreach my $img (@imglist) {
346			chomp $img;
347			# stat the img
348			my($dev,$ino,$mode,$nlink,$uid,$gid,$rdev,$size,$atime,$mtime,
349			$ctime,$blksize,$blocks) = stat("$imgdir/$machine/$img");
350			# check if it's old enough to be deleted
351			if((time - $mtime) > $maximgage) {
352			# if so, delete it
353			unlink("$imgdir/$machine/$img");
354	tdb	1.5	&log("deleted old image $imgdir/$machine/$img\n");
355	tdb	1.4	}
356			}
357			# have a last check, maybe we can remove the directory now?
358			# Read the contents of the directory
359			opendir(DIR, "$imgdir/$machine");
360			my(@dirlist) = grep { !/^\.$/ && !/^\.\.$/ } readdir(DIR);
361			closedir DIR;
362			if($#dirlist == -1) {
363			rmdir "$imgdir/$machine";
364	tdb	1.5	&log("deleted empty image directory $imgdir/$machine\n");
365	tdb	1.3	}
366			}
367	tdb	1.1	}
368	tdb	1.4
369			exit(0);
370
371	tdb	1.1
372			#
373			# subroutine to make some graphs
374			#
375			# $machine = name of the machine
376			# (eg. kernow.ukc.ac.uk)
377			# $type = the type of graph for the machine
378			# (eg. cpu)
379			# $title = the title for the graph
380			# (eg. kernow CPU usage)
381	tdb	1.10	# $vlabel = the vertical label to apply to the left side of the graph
382			# (eg. kb/s)
383	tdb	1.1	# $dataref = a reference to an array containing information for the graph
384	tdb	1.7	# elements of format: "gtype:rrdname:dsname:name#colour:legend:comment with spaces"
385	tdb	1.1	# (if gtype is "NONE" only a DEF of 'name' will be defined, no line will be plotted)
386	tdb	1.7	# (if legend is "NONE" the latest/average/max/min legend won't be printed)
387	tdb	1.1	# $rawcmdref = a reference to an array containing raw rrd commands
388			# elements a single command each, no spaces
389			#
390
391			sub makegraph() {
392	tdb	1.10	my($machine, $type, $title, $vlabel, $dataref, $rawcmdref) = @_;
393	tdb	1.1	# pass in these arrays by reference
394			my(@data) = @$dataref if defined $dataref;
395			my(@rawcmd) = @$rawcmdref if defined $rawcmdref;
396			# check if directory exists for images
397			if(! -d "$imgdir/$machine") {
398			# not sure on this umask, but it seems to work?
399			mkdir "$imgdir/$machine", 0777;
400	tdb	1.5	&log("created directory $imgdir/$machine\n");
401	tdb	1.1	}
402			my(@rrdcmd);
403			foreach my $dataitem (@data) {
404	tdb	1.7	# dataitem should be: "gtype:rrdname:dsname:name#colour:legend:comment with spaces"
405	tdb	1.1	# (if gtype is "NONE" only a DEF of 'name' will be defined, no line will be plotted)
406	tdb	1.7	# (if legend is "NONE" the latest/average/max/min legend won't be printed)
407			if($dataitem =~ /^(\S+):(\S+):(\S+):(\S+)#(.{6}):(\S+):(.*)$/) {
408	tdb	1.1	push @rrdcmd, "DEF:$4=$rrddir/$machine/$2.rrd:$3:AVERAGE";
409			if($1 ne "NONE") {
410	tdb	1.8	push @rrdcmd, "$1:$4#$5:$7";
411	tdb	1.7	if($6 ne "NONE") {
412			# add some nice values to the legend
413			&addlegend(\@rrdcmd, $4);
414			}
415	tdb	1.1	}
416			}
417			}
418			push @rrdcmd, "--title=$title";
419			push @rrdcmd, "--imgformat=PNG";
420			push @rrdcmd, "--lower-limit=0";
421	tdb	1.10	push @rrdcmd, "--vertical-label=$vlabel";
422	tdb	1.1	# not entirely convinced this is good...
423			push @rrdcmd, "--alt-autoscale-max";
424			# add any further raw commands
425			push @rrdcmd, @rawcmd;
426			RRDs::graph ("$imgdir/$machine/$type-3h.png", "--start=-10800", @rrdcmd);
427			my($err_3h) = RRDs::error;
428	tdb	1.5	&log("created $imgdir/$machine/$type-3h.png\n") unless $err_3h;
429			&error("Error generating 3h graph for $machine/$type: $err_3h\n") if $err_3h;
430	tdb	1.1	RRDs::graph ("$imgdir/$machine/$type-1d.png", "--start=-86400", @rrdcmd);
431			my($err_1d) = RRDs::error;
432	tdb	1.5	&log("created $imgdir/$machine/$type-1d.png\n") unless $err_1d;
433			&error("Error generating 1d graph for $machine/$type: $err_1d\n") if $err_1d;
434	tdb	1.1	RRDs::graph ("$imgdir/$machine/$type-1w.png", "--start=-604800", @rrdcmd);
435			my($err_1w) = RRDs::error;
436	tdb	1.5	&log("created $imgdir/$machine/$type-1w.png\n") unless $err_1w;
437			&error("Error generating 1w graph for $machine/$type: $err_1w\n") if $err_1w;
438	tdb	1.1	RRDs::graph ("$imgdir/$machine/$type-1m.png", "--start=-2678400", @rrdcmd);
439			my($err_1m) = RRDs::error;
440	tdb	1.5	&log("created $imgdir/$machine/$type-1m.png\n") unless $err_1m;
441			&error("Error generating 1m graph for $machine/$type: $err_1m\n") if $err_1m;
442	tdb	1.1	RRDs::graph ("$imgdir/$machine/$type-1y.png", "--start=-31536000", @rrdcmd);
443			my($err_1y) = RRDs::error;
444	tdb	1.5	&log("created $imgdir/$machine/$type-1y.png\n") unless $err_1y;
445			&error("Error generating 1y graph for $machine/$type: $err_1y\n") if $err_1y;
446	tdb	1.1	return;
447	tdb	1.7	}
448
449			# subroutine to add a legend
450			# accepts reference to an array and a name
451			sub addlegend() {
452			my($dataref, $name) = @_;
453	tdb	1.8	push @$dataref, "GPRINT:$name:LAST:Current\\: \%8.2lf %s";
454			push @$dataref, "GPRINT:$name:AVERAGE:Average\\: \%8.2lf %s";
455			push @$dataref, "GPRINT:$name:MAX:Max\\: \%8.2lf %s\\n";
456	tdb	1.1	}
457
458			# hacky subroutine to return a colour
459			# could be done much better somehow :/
460			sub get_colour {
461			my($col) = @_;
462			if($col == 0) {
463			return "#0000FF";
464			}
465			elsif($col == 1) {
466			return "#00FF00";
467			}
468			elsif($col == 2) {
469			return "#FF00FF";
470			}
471			elsif($col == 3) {
472			return "#FFFF00";
473			}
474			elsif($col == 4) {
475			return "#00FFFF";
476			}
477			else {
478			return "#000066";
479			}
480	tdb	1.5	}
481
482			# prints out usage information then exits
483			sub usage() {
484			print "Usage: graph.pl [options]\n";
485			print "Options\n";
486			print " -c config Specifies the configuration file\n";
487			print " default: rrdgraphing.conf\n";
488			print " -v Be verbose about what's happening\n";
489			print " -q Be quiet, even supress errors\n";
490			print " -V Print version number\n";
491			print " -h Prints this help page\n";
492			exit(1);
493			}
494
495			# prints a log message if verbose is turned on
496			sub log() {
497			my($msg) = @_;
498			print $msg if $verbose;
499			}
500
501			# prints an error message unless quiet is turned on
502			sub error() {
503			my($msg) = @_;
504			print STDERR $msg unless $quiet;
505	tdb	1.1	}