src/lib/Torrus/DataAccess.pm

   1 #  Copyright (C) 2002  Stanislav Sinyagin
   2 #
   3 #  This program is free software; you can redistribute it and/or modify
   4 #  it under the terms of the GNU General Public License as published by
   5 #  the Free Software Foundation; either version 2 of the License, or
   6 #  (at your option) any later version.
   7 #
   8 #  This program is distributed in the hope that it will be useful,
   9 #  but WITHOUT ANY WARRANTY; without even the implied warranty of
  10 #  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11 #  GNU General Public License for more details.
  12 #
  13 #  You should have received a copy of the GNU General Public License
  14 #  along with this program; if not, write to the Free Software
  15 #  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.
  16
  17 # $Id$
  18 # Stanislav Sinyagin <ssinyagin@yahoo.com>
  19
  20 package Torrus::DataAccess;
  21 use strict;
  22 use warnings;
  23
  24 use Torrus::ConfigTree;
  25 use Torrus::Log;
  26 use Torrus::RPN;
  27
  28 use RRDs;
  29
  30 our $VERSION = 1.0;
  31
  32 # The Torrus::DataAccess object contains cached values, and it does not
  33 # check the cache validity. We assume that a Torrus::DataAccess object
  34 # lifetime is within a short period of time, such as one monitor cycle.
  35
  36 sub new
  37 {
  38     my $self = {};
  39     my $class = shift;
  40     bless $self, $class;
  41     return $self;
  42 }
  43
  44 # Read the data from datasource file, depending on its type.
  45 # If time is not specified, reads the latest available data.
  46 # In case of rrd-cdef leaf type, the returned timestamp is the
  47 # earliest timestamp of the data sources involved.
  48 #
  49 # ($value, $timestamp) = $da->read( $config_tree, $leaf_token )
  50 #
  51 # ($value, $timestamp) = $da->read( $config_tree, $leaf_token, $end_time )
  52 #
  53 # ($value, $timestamp) = $da->read( $config_tree, $leaf_token,
  54 #                                   $end_time, $start_time )
  55
  56
  57 sub read
  58 {
  59     my $self = shift;
  60     my $config_tree = shift;
  61     my $token = shift;
  62     my $t_end = shift;
  63     my $t_start = shift;
  64
  65     my $cachekey = $token .
  66         ':' . (defined($t_end)?$t_end:'') .
  67         ':' . (defined($t_start)?$t_start:'');
  68
  69     if( exists( $self->{'cache_read'}{$cachekey} ) )
  70     {
  71         return @{$self->{'cache_read'}{$cachekey}};
  72     }
  73
  74     if( not $config_tree->isLeaf( $token ) )
  75     {
  76         my $path = $config_tree->path( $token );
  77         Error("Torrus::DataAccess::readLast: $path is not a leaf");
  78         return
  79     }
  80
  81     my $ret_val;
  82     my $ret_time;
  83
  84     my $ds_type = $config_tree->getNodeParam( $token, 'ds-type' );
  85     if( $ds_type eq 'rrd-file' or
  86         $ds_type eq 'collector' )
  87     {
  88         my $leaf_type = $config_tree->getNodeParam( $token, 'leaf-type' );
  89
  90         if( $leaf_type eq 'rrd-def' )
  91         {
  92             my $file = $config_tree->getNodeParam( $token, 'data-file' );
  93             my $dir = $config_tree->getNodeParam( $token, 'data-dir' );
  94             my $ds = $config_tree->getNodeParam( $token, 'rrd-ds' );
  95             my $cf = $config_tree->getNodeParam( $token, 'rrd-cf' );
  96             ( $ret_val, $ret_time ) =
  97                 $self->read_RRD_DS( $dir.'/'.$file,
  98                                     $cf, $ds, $t_end, $t_start );
  99         }
 100         elsif( $leaf_type eq 'rrd-cdef' )
 101         {
 102             my $expr = $config_tree->getNodeParam( $token, 'rpn-expr' );
 103             ( $ret_val, $ret_time ) =
 104                 $self->read_RPN( $config_tree, $token, $expr,
 105                                  $t_end, $t_start );
 106
 107         }
 108         else
 109         {
 110             my $path = $config_tree->path( $token );
 111             Error("$path: leaf-type $leaf_type is not supported ".
 112                   "for data access");
 113         }
 114     }
 115     else
 116     {
 117         my $path = $config_tree->path( $token );
 118         Error("$path: ds-type $ds_type is not supported ".
 119               "for data access");
 120     }
 121
 122     $self->{'cache_read'}{$cachekey} = [ $ret_val, $ret_time ];
 123     return ( $ret_val, $ret_time );
 124 }
 125
 126
 127 sub read_RRD_DS
 128 {
 129     my $self = shift;
 130     my $filename = shift;
 131     my $cf = shift;
 132     my $ds = shift;
 133     my $t_end = shift;
 134     my $t_start = shift;
 135
 136     my $cachekey = $filename . ':' . $cf .
 137         ':' . (defined($t_end)?$t_end:'') .
 138         ':' . (defined($t_start)?$t_start:'');
 139
 140     if( exists( $self->{'cache_RRD'}{$cachekey}{$ds} ) )
 141     {
 142         return @{$self->{'cache_RRD'}{$cachekey}{$ds}};
 143     }
 144
 145     my $rrdinfo = RRDs::info( $filename );
 146     my $ERR = RRDs::error;
 147     if( $ERR )
 148     {
 149         Error("Error during RRD info for $filename: $ERR");
 150         return
 151
 152     }
 153     my $step = $rrdinfo->{'step'};
 154     my $last_available = $rrdinfo->{'last_update'};
 155     $last_available -= $last_available % $step;
 156
 157     if( not defined $t_end )
 158     {
 159         $t_end = $last_available;
 160     }
 161     elsif( index( $t_end, 'LAST' ) >= 0 )
 162     {
 163         $t_end =~ s/LAST/$last_available/g;
 164     }
 165
 166     if( not defined $t_start )
 167     {
 168         $t_start = $t_end . '-' . int($step * 3);
 169     }
 170     elsif( index( $t_start, 'LAST' ) >= 0 )
 171     {
 172         $t_start =~ s/LAST/$last_available/g;
 173     }
 174
 175     # From here on, f_ prefix means fetch results
 176     my( $f_start, $f_step, $f_names, $f_data ) =
 177         RRDs::fetch( $filename, $cf, '--start', $t_start, '--end', $t_end );
 178     $ERR = RRDs::error;
 179     if( $ERR )
 180     {
 181         Error("Error during RRD fetch for $filename: $ERR");
 182         return
 183
 184     }
 185
 186     # Memorize the DS names in cache
 187
 188     for( my $i = 0; $i < @{$f_names}; $i++ )
 189     {
 190         $self->{'cache_RRD'}{$cachekey}{$f_names->[$i]} = [];
 191     }
 192
 193     # Get the last available data and store in cache
 194
 195     for my $f_line ( @{$f_data} )
 196     {
 197         for( my $i = 0; $i < @{$f_names}; $i++ )
 198         {
 199             if( defined $f_line->[$i] )
 200             {
 201                 $self->{'cache_RRD'}{$cachekey}{$f_names->[$i]} =
 202                     [ $f_line->[$i], $f_start ];
 203             }
 204         }
 205         $f_start += $f_step;
 206     }
 207
 208     if( not exists( $self->{'cache_RRD'}{$cachekey}{$ds} ) )
 209     {
 210         Error("DS name $ds is not found in $filename");
 211         return
 212     }
 213     else
 214     {
 215         if( scalar( @{$self->{'cache_RRD'}{$cachekey}{$ds}} ) == 0 )
 216         {
 217             Warn("Value undefined for ",
 218                  "DS=$ds, CF=$cf, start=$t_start, end=$t_end in $filename");
 219             return
 220         }
 221         else
 222         {
 223             return @{$self->{'cache_RRD'}{$cachekey}{$ds}};
 224         }
 225     }
 226 }
 227
 228
 229
 230 # Data access for other CF than defined for the leaf doesn't make much
 231 # sense. So we ignore the CF in DataAccess and leave it for the
 232 # sake of Renderer compatibility
 233 my %cfNames =
 234     ( 'AVERAGE' => 1,
 235       'MIN'     => 1,
 236       'MAX'     => 1,
 237       'LAST'    => 1 );
 238
 239
 240 sub read_RPN
 241 {
 242     my $self = shift;
 243     my $config_tree = shift;
 244     my $token = shift;
 245     my $expr = shift;
 246     my $t_end = shift;
 247     my $t_start = shift;
 248
 249     my @expr_list = split(',', $expr);
 250     my @eval_expr;
 251     my $timestamp = $t_end > 0 ? $t_end : time();
 252
 253     my $rpn = Torrus::RPN->new();
 254
 255     my $callback = sub
 256     {
 257         my ($noderef, $timeoffset) = @_;
 258
 259         my $function;
 260         if( $noderef =~ s/^(.)\@// )
 261         {
 262             $function = $1;
 263         }
 264
 265         my $leaf = length($noderef) > 0 ?
 266             $config_tree->getRelative($token, $noderef) : $token;
 267
 268         if( not defined $leaf )
 269         {
 270             my $path = $config_tree->path($token);
 271             Error("Cannot find relative reference $noderef at $path");
 272             return
 273         }
 274
 275         my ($rval, $var_tstamp) = $self->read($config_tree,
 276                                               $leaf,
 277                                               $timeoffset,
 278                                               $t_start);
 279         if( defined $rval )
 280         {
 281             if( $var_tstamp == 0 )
 282             {
 283                 Warn("Torrus::DataAccess::read retirned zero timestamp ".
 284                      "for $leaf");
 285             }
 286
 287             if( $var_tstamp < $timestamp )
 288             {
 289                 $timestamp = $var_tstamp;
 290             }
 291         }
 292
 293         if( defined( $function ) )
 294         {
 295             if( $function eq 'T' )
 296             {
 297                 return $var_tstamp;
 298             }
 299             elsif( not $cfNames{$function} )
 300             {
 301                 Error("Function not supported in RPN: $function");
 302                 return
 303             }
 304         }
 305         return $rval;
 306     };
 307
 308     my $result = $rpn->run( $expr, $callback );
 309
 310     return ( $result, $timestamp );
 311 }
 312
 313 1;
 314
 315
 316 # Local Variables:
 317 # mode: perl
 318 # indent-tabs-mode: nil
 319 # perl-indent-level: 4
 320 # End: