Changeset 1252

Show
Ignore:
Timestamp:
11/17/06 23:58:36 (5 years ago)
Author:
janl
Message:

Move SNMP.pm and work on the other modules

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • people/janl/src/libperl/Munin.pm

    r1251 r1252  
    11package Munin; 
    2 # -*- perl -*- 
    32# 
    43# Copyright (C) 2003-2006 Jimmy Olsen, Audun Ytterdal, Nicolai Langfeldt 
    …… 
    2625            @legalconfig @copy_fields); 
    2726 
    28 @ISA = ('Exporter'); 
    29  
    30 @EXPORT = ('munin_trend', 
    31            'munin_fetch', 
    32            'munin_nscasend', 
    33            'munin_createlock', 
    34            'munin_removelock', 
    35            'munin_runlock', 
    36            'munin_getlock', 
    37            'munin_delete', 
    38            'munin_overwrite', 
    39            'munin_draw_field', 
    40            'munin_get_bool', 
    41            'munin_get_bool_val', 
    42            'munin_get', 
    43            'munin_field_status', 
    44            'munin_service_status', 
    45            'munin_node_status', 
    46            'munin_category_status', 
    47            'munin_get_picture_filename', 
    48            'munin_get_filename', 
    49            'munin_graph_column_headers', 
    50            'munin_get_max_label_length', 
    51            'munin_get_field_order', 
    52            'munin_get_rrd_filename', 
    53            '$CONFDIR', 
    54            '$DEBUG', 
    55            ); 
     27@ISA = qw(main Exporter); 
     28 
     29@EXPORT = qw(munin_createlock 
     30             munin_removelock munin_runlock munin_getlock munin_delete 
     31             munin_overwrite munin_draw_field munin_get_bool 
     32             munin_get_bool_val munin_get munin_field_status 
     33             munin_service_status munin_node_status 
     34             munin_category_status munin_get_picture_filename 
     35             munin_get_filename munin_graph_column_headers 
     36             munin_get_max_label_length munin_get_field_order 
     37             munin_get_rrd_filename $CONFDIR $DEBUG ); 
    5638 
    5739@EXPORT_OK = ''; # qw($CONFDIR); 
    58  
    59 $VERSION='@@VERSION@@'; 
    60 $CONFDIR='@@CONFDIR@@'; 
    6140 
    6241use RRDs; 
    …… 
    6544use Symbol 'gensym'; 
    6645 
    67 $VERSION = '@@VERSION@@'; 
    68  
    6946my $nsca = new IO::Handle; 
    7047my $config = undef; 
    71  
    7248$DEBUG=0; 
     49 
    7350my $configfile='@@CONFDIR@@/munin.conf'; 
    7451 
    …… 
    140117$ENV{'MUNIN_MKTEMP'}     = $MKTEMP; 
    141118 
    142 sub munin_trend { 
    143     my (@array) = @_; 
    144     return ($array[$#array] - $array[0]); 
    145 } 
    146  
    147 sub munin_fetch { 
    148     my ($file,$last,$type) = @_; 
    149     my ($start,$step,$names,$data) = RRDs::fetch $file,$type || "AVERAGE"; 
    150     unless (defined $data) 
    151     { 
    152         ::logger ("Could not fetch data from $file(".($type||"AVERAGE")."): ". RRDs::error); 
    153         return undef; 
    154     } 
    155     my @array = map { @$_[0] } splice(@$data, $#$data - ($last || 1)); 
    156     return $array[0] if (!$last); 
    157     return @array; 
    158 } 
    159  
    160 sub munin_draw_field { 
    161     my $node    = shift; 
    162     my $service = shift; 
    163     my $field   = shift; 
    164  
    165     $field =~ s/=.*//; 
    166  
    167     print "DEBUG: munin_draw_field: Checking $service -> $field: " . &munin_get_bool_val ($node->{client}->{$service}->{$field.".graph"}, 1) . ".\n" if $DEBUG;; 
    168     return 0 if (exists $node->{client}->{$service}->{$field.".skipdraw"}); 
    169     return (&munin_get_bool_val ($node->{client}->{$service}->{$field.".graph"}, 1)); 
    170 } 
    171  
    172 sub munin_nscasend { 
    173     my ($name,$service,$label,$level,$comment) = @_; 
    174  
    175     if (!$nsca->opened) 
    176     { 
    177         open ($nsca ,"|$config->{nsca} $config->{nsca_server} -c $config->{nsca_config} -to 60"); 
    178     } 
    179     if ($label) 
    180     { 
    181         print $nsca  "$name\t$service: $label\t$level\t$comment\n"; 
    182         print ("$name;$service: $label;$level;$comment\n") if $DEBUG; 
    183     } 
    184     else 
    185     { 
    186         print $nsca  "$name\t$service\t$level\t$comment\n"; 
    187         print ("$name;$service;$level;$comment\n") if $DEBUG; 
    188     } 
    189 } 
    190  
    191119sub munin_createlock { 
    192120    # Create lock file, fail and die if not possible. 
    193121    my ($lockname) = @_; 
    194122    if (sysopen (LOCK,$lockname,O_WRONLY | O_CREAT | O_EXCL)) { 
    195         print "Creating lock : $lockname succeded\n" if $DEBUG; 
     123        print "Creating lock : $lockname succeded\n" if $::DEBUG; 
    196124        print LOCK $$; # we want the pid inside for later use 
    197125        close LOCK; 
    …… 
    201129    } 
    202130} 
     131 
    203132 
    204133sub munin_removelock { 
    …… 
    242171} 
    243172 
     173 
    244174sub munin_delete { 
     175    # Delete a domain, and corresponding set of nodes from config tree 
     176 
    245177    my ($config,$data) = @_; 
    246178    for my $domain (keys %{$data->{domain}}) { 
    247         unless ($config->{domain}->{$domain}) { 
     179        if (!$config->{domain}->{$domain}) { 
    248180            ::logger("Removing domain: $domain"); 
    249181            delete ($data->{domain}->{$domain}); 
    …… 
    259191    return ($data); 
    260192} 
     193 
     194 
    261195sub munin_overwrite { 
    262196    my ($configfile,$overwrite) = @_; 
    …… 
    287221    $scale =~ s/[^\w_\/"'\[\]\(\)+=-]/_/g; 
    288222 
    289     if (defined $sum and $sum) 
    290     { 
     223    if (defined $sum and $sum) { 
    291224            return "$dir/$domain/$name-$service-$scale-sum.png"; 
    292     } 
    293     else 
    294     { 
     225    } else { 
    295226            return "$dir/$domain/$name-$service-$scale.png"; 
    296227    } 
    …… 
    300231        my ($config,$domain,$node,$service,$field) = @_; 
    301232 
    302         return ($config->{'dbdir'} . "/$domain/$node-$service-$field-" . lc substr (($config->{domain}->{$domain}->{node}->{$node}->{client}->{$service}->{$field.".type"}||"GAUGE"), 0,1). ".rrd"); 
    303  
    304 } 
    305  
    306 sub munin_get_bool 
    307 { 
     233        return ($config->{'dbdir'} . "/$domain/$node-$service-$field-". 
     234                lc substr (($config->{domain}->{$domain}->{node}->{$node}->{client}->{$service}->{$field.".type"}||"GAUGE"), 0,1). ".rrd"); 
     235} 
     236 
     237 
     238sub munin_get_bool { 
    308239    my $conf     = shift; 
    309240    my $field    = shift; 
    …… 
    324255        $ans =~ /^enable$/i or 
    325256        $ans =~ /^enabled$/i 
    326        ) 
    327     { 
    328     return 1; 
    329     } 
    330     elsif ($ans =~ /^no$/i or 
    331         $ans =~ /^false$/i or 
    332         $ans =~ /^off$/i or 
    333         $ans =~ /^disable$/i or 
    334         $ans =~ /^disabled$/i 
    335       ) 
    336     { 
    337     return 0; 
    338     } 
    339     elsif ($ans !~ /\D/) 
    340     { 
    341     return $ans; 
    342     } 
    343     else 
    344     { 
    345     return undef; 
     257       ) { 
     258        return 1; 
     259    } elsif ($ans =~ /^no$/i or 
     260             $ans =~ /^false$/i or 
     261             $ans =~ /^off$/i or 
     262             $ans =~ /^disable$/i or 
     263             $ans =~ /^disabled$/i) { 
     264        return 0; 
     265    } elsif ($ans !~ /\D/) { 
     266        return $ans; 
     267    } else { 
     268        return undef; 
    346269    } 
    347270} 
    …… 
    352275    my $default  = shift; 
    353276 
    354     if (!defined $field) 
    355     { 
    356     if (!defined $default) 
    357     { 
    358         return 0; 
    359     } 
    360     else 
    361     { 
    362         return $default; 
    363     } 
     277    if (!defined $field) { 
     278        if (!defined $default) { 
     279            return 0; 
     280        } else { 
     281            return $default; 
     282        } 
    364283    } 
    365284 
    …… 
    368287        $field =~ /^on$/i or 
    369288        $field =~ /^enable$/i or 
    370         $field =~ /^enabled$/i 
    371        ) 
    372     { 
    373     return 1; 
    374     } 
    375     elsif ($field =~ /^no$/i or 
     289        $field =~ /^enabled$/i) { 
     290        return 1; 
     291    } elsif ($field =~ /^no$/i or 
    376292        $field =~ /^false$/i or 
    377293        $field =~ /^off$/i or 
    378294        $field =~ /^disable$/i or 
    379         $field =~ /^disabled$/i 
    380       ) 
    381     { 
    382     return 0; 
    383     } 
    384     elsif ($field !~ /\D/) 
    385     { 
    386     return $field; 
    387     } 
    388     else 
    389     { 
    390     return undef; 
    391     } 
    392 } 
    393  
    394 sub munin_get 
    395 { 
     295        $field =~ /^disabled$/i) { 
     296        return 0; 
     297    } elsif ($field !~ /\D/) { 
     298        return $field; 
     299    } else { 
     300        return undef; 
     301    } 
     302} 
     303 
     304sub munin_get { 
     305 
     306    # Fetch value from configuration tree.  Start at deepest level and 
     307    # "recurse" upwards.  This allows defaulting at shalow levels and 
     308    # specific overrides at deeper levels. 
     309 
    396310    my $conf     = shift; 
    397311    my $field    = shift; 
    …… 
    402316    my $plot     = shift; 
    403317 
    404     if (defined $field) 
    405     { 
     318    if (defined $field) { 
     319 
    406320        return $conf->{domain}->{$domain}->{node}->{$node}->{client}->{$service}->{"$plot.$field"} 
    407                 if (defined $domain and defined $node and defined $service and defined $plot and  
    408                         defined $conf->{domain}->{$domain}->{node}->{$node}->{client}->{$service}->{"$plot.$field"}); 
    409  
     321          if (defined $domain and 
     322              defined $node and 
     323              defined $service and 
     324              defined $plot and 
     325              defined $conf->{domain}->{$domain}->{node}->{$node}->{client}->{$service}->{"$plot.$field"}); 
     326 
     327        return $conf->{domain}->{$domain}->{node}->{$node}->{client}->{$service}->{$field} 
     328          if (defined $domain and 
     329              defined $node and 
     330              defined $service and 
     331              defined $conf->{domain}->{$domain}->{node}->{$node}->{client}->{$service}->{$field}); 
     332 
     333        return $conf->{domain}->{$domain}->{node}->{$node}->{$field} 
     334          if (defined $domain and 
     335              defined $node and 
     336              defined $conf->{domain}->{$domain}->{node}->{$node}->{$field}); 
    410337         
    411  
    412         return $conf->{domain}->{$domain}->{node}->{$node}->{client}->{$service}->{$field} 
    413                 if (defined $domain and defined $node and defined $service and  
    414                         defined $conf->{domain}->{$domain}->{node}->{$node}->{client}->{$service}->{$field}); 
    415         return $conf->{domain}->{$domain}->{node}->{$node}->{$field} 
    416                 if (defined $domain and defined $node and  
    417                         defined $conf->{domain}->{$domain}->{node}->{$node}->{$field}); 
    418338        return $conf->{domain}->{$domain}->{$field} 
    419                 if (defined $domain and defined $conf->{domain}->{$domain}->{$field}); 
     339          if (defined $domain and 
     340              defined $conf->{domain}->{$domain}->{$field}); 
     341 
    420342        return $conf->{$field} 
    421                 if (defined $conf->{$field}); 
     343          if (defined $conf->{$field}); 
     344 
    422345        return $default; 
    423     } 
    424     else 
    425     { 
     346 
     347    } else { 
     348 
    426349        return $conf->{domain}->{$domain}->{node}->{$node}->{client}->{$service} 
    427                 if (defined $domain and defined $node and defined $service and  
    428                         defined $conf->{domain}->{$domain}->{node}->{$node}->{client}->{$service}); 
     350          if (defined $domain and 
     351              defined $node and 
     352              defined $service and 
     353              defined $conf->{domain}->{$domain}->{node}->{$node}->{client}->{$service}); 
     354 
    429355        return $conf->{domain}->{$domain}->{node}->{$node} 
    430                 if (defined $domain and defined $node and  
    431                         defined $conf->{domain}->{$domain}->{node}->{$node}); 
     356          if (defined $domain and 
     357              defined $node and 
     358              defined $conf->{domain}->{$domain}->{node}->{$node}); 
     359 
    432360        return $conf->{domain}->{$domain} 
    433                 if (defined $domain and defined $conf->{domain}->{$domain}); 
     361          if (defined $domain and 
     362              defined $conf->{domain}->{$domain}); 
     363 
    434364        return $conf 
    435                 if (defined $conf); 
     365          if (defined $conf); 
     366 
    436367        return $default; 
    437368    } 
    438369} 
    439370 
    440 sub munin_node_status 
    441 { 
     371 
     372sub munin_node_status { 
    442373    my ($config, $limits, $domain, $node, $check_draw) = @_; 
    443374    my $state = "ok"; 
    …… 
    446377    my $snode = $config->{domain}->{$domain}->{node}->{$node}; 
    447378 
    448     foreach my $service (keys %{$snode}) 
    449     { 
    450         my $fres  = &munin_service_status ($config, $limits, $domain, $node, $service, $check_draw); 
    451         if (defined $fres) 
    452         { 
    453             if ($fres eq "critical") 
    454             { 
     379    foreach my $service (keys %{$snode}) { 
     380        my $fres = &munin_service_status ($config, $limits, 
     381                                          $domain, $node, 
     382                                          $service, $check_draw); 
     383        if (defined $fres) { 
     384            if ($fres eq "critical") { 
    455385                $state = $fres; 
    456386                last; 
    457             } 
    458             elsif ($fres eq "warning") 
    459             { 
     387            } elsif ($fres eq "warning") { 
    460388                $state = $fres; 
    461389            } 
    …… 
    466394} 
    467395 
    468 sub munin_category_status 
    469 { 
     396 
     397sub munin_category_status { 
    470398    my ($config, $limits, $domain, $node, $category, $check_draw) = @_; 
    471399    my $state = "ok"; 
    …… 
    474402    my $snode = $config->{domain}->{$domain}->{node}->{$node}; 
    475403 
    476     foreach my $service (keys %{$snode->{client}}) 
    477     { 
    478         next if ((not defined $snode->{client}->{$service}->{graph_category}) and 
    479                 $category ne 'other'); 
    480         next if ((defined $snode->{client}->{$service}->{graph_category}) and  
    481                  ($snode->{client}->{$service}->{graph_category} ne $category)); 
    482  
    483         my $fres  = &munin_service_status ($config, $limits, $domain, $node, $service, $check_draw); 
    484         if (defined $fres) 
    485         { 
    486             if ($fres eq "critical") 
    487             { 
     404    foreach my $service (keys %{$snode->{client}}) { 
     405        next if ((not defined $snode->{client}->{$service}->{graph_category}) 
     406                 and $category ne 'other'); 
     407 
     408        next if ((defined $snode->{client}->{$service}->{graph_category}) and 
     409                 ($snode->{client}->{$service}->{graph_category} ne 
     410                  $category)); 
     411 
     412        my $fres  = &munin_service_status ($config, $limits, 
     413                                           $domain, $node, 
     414                                           $service, $check_draw); 
     415 
     416        if (defined $fres) { 
     417            if ($fres eq "critical") { 
    488418                $state = $fres; 
    489419                last; 
    490             } 
    491             elsif ($fres eq "warning") 
    492             { 
     420            } elsif ($fres eq "warning") { 
    493421                $state = $fres; 
    494422            } 
    …… 
    499427} 
    500428 
    501 sub munin_service_status 
    502 { 
     429 
     430sub munin_service_status { 
    503431    my ($config, $limits, $domain, $node, $service, $check_draw) = @_; 
    504432    my $state = "ok"; 
    505433 
    506     return undef unless defined $config->{domain}->{$domain}->{node}->{$node}->{client}->{$service}; 
    507     foreach my $key (keys %{$config->{domain}->{$domain}->{node}->{$node}->{client}->{$service}}) 
    508     { 
     434    return undef 
     435      unless defined $config->{domain}->{$domain}->{node}->{$node}->{client}->{$service}; 
     436 
     437    foreach my $key (keys %{$config->{domain}->{$domain}->{node}->{$node}->{client}->{$service}}) { 
    509438        next unless $key =~ /^([^\.]+)\.label$/; 
    510439        my $field = $1; 
    511         my $fres  = &munin_field_status ($config, $limits, $domain, $node, $service, $field, $check_draw); 
    512         if (defined $fres) 
    513         { 
    514             if ($fres eq "critical") 
    515             { 
     440        my $fres  = &munin_field_status ($config, $limits, $domain, 
     441                                        $node, $service, $field, $check_draw); 
     442 
     443        if (defined $fres) { 
     444            if ($fres eq "critical") { 
    516445                $state = $fres; 
    517446                last; 
    518             } 
    519             elsif ($fres eq "warning") 
    520             { 
     447            } elsif ($fres eq "warning") { 
    521448                $state = $fres; 
    522449            } 
    523450        } 
    524451    } 
    525  
    526452    return $state; 
    527453} 
    528454 
    529 sub munin_field_status 
    530 { 
     455 
     456sub munin_field_status { 
     457    # Something to do with warning and critical levels. 
     458 
     459    # Appears to not set warning/critical state if "nagios" is turned 
     460    # off.  Isn't that a bit odd? 
     461 
    531462    my ($config, $limits, $domain, $node, $service, $field, $check_draw) = @_; 
    532463    my $state = undef; 
    …… 
    534465    # Return undef if nagios is turned off, or the field doesn't have any limits 
    535466    unless ((defined $config->{domain}->{$domain}->{node}->{$node}->{client}->{$service}->{"$field.warning"}) or 
    536         (defined $config->{domain}->{$domain}->{node}->{$node}->{client}->{$service}->{"$field.critical"})) 
    537     { 
     467        (defined $config->{domain}->{$domain}->{node}->{$node}->{client}->{$service}->{"$field.critical"})) { 
    538468        return undef; 
    539469    } 
    540470 
    541     if (defined $limits->{domain}->{$domain}->{node}->{$node}->{client}->{$service}->{"$field.critical"} and (!defined $check_draw or !$check_draw or  
    542                 &munin_draw_field ($config->{domain}->{$domain}->{node}->{$node}, $service, $field))) 
     471    if (defined $limits->{domain}->{$domain}->{node}->{$node}->{client}->{$service}->{"$field.critical"} and 
     472        (!defined $check_draw or !$check_draw or 
     473         &munin_draw_field ($config->{domain}->{$domain}->{node}->{$node}, $service, $field))) 
    543474    { 
    544475        return "critical"; 

  • people/janl/src/libperl/Munin/Server.pm

    r1251 r1252  
    99            @EXPORT $VERSION); 
    1010 
    11 @ISA = qw(Munin Exporter); 
    12  
    13 @EXPORT= qw($configfile @legal %legal_expanded @copy_fields 
    14             munin_readconfig munin_parse_config 
    15            ); 
     11@ISA = qw(main Munin Exporter); 
     12 
     13@EXPORT = qw( 
     14 
     15             $configfile @legal %legal_expanded @copy_fields 
     16             munin_readconfig munin_parse_config munin_trend 
     17             munin_fetch munin_nscasend 
     18 
     19            ); 
    1620 
    1721$configfile='@@CONFDIR@@/munin.conf'; 
    …… 
    3034            category_order version tls_certificate tls_private_key 
    3135            tls_pem tls_verify_certificate tls_verify_depth 
    32             graph_data_size 
    33            ); 
     36            graph_data_size); 
    3437 
    3538push(@legal,@Munin::legalfetch,@Munin::legalconfig); 
    …… 
    5255                return undef; 
    5356    } 
    54     if (open (CFG, $conf)) 
    55     { 
     57    if (open (CFG, $conf)) { 
    5658        @contents = <CFG>; 
    5759        close (CFG); 
    …… 
    6870    return ($config); 
    6971} 
     72 
    7073 
    7174sub munin_parse_config { 
    …… 
    132135 
    133136    print "DEBUG: Getting var \"$var\" = \"$val\"\n" if $::DEBUG; 
    134     if ($var =~ /^\s*([^;:]+);([^;:]+):(\S+)\s*$/) 
    135     { 
     137    if ($var =~ /^\s*([^;:]+);([^;:]+):(\S+)\s*$/) { 
    136138        my ($dom, $host, $rest) = ($1, $2, $3); 
    137139        my @sp = split (/\./, $rest); 
    138140 
    139         if (@sp == 3) 
    140         { 
     141        if (@sp == 3) { 
    141142            return $hash->{domain}->{$dom}->{node}->{$host}->{client}->{$sp[0]}->{"$sp[1].$sp[2]"}; 
    142         } 
    143         elsif (@sp == 2) 
    144         { 
     143        } elsif (@sp == 2) { 
    145144            return $hash->{domain}->{$dom}->{node}->{$host}->{client}->{$sp[0]}->{$sp[1]}; 
    146         } 
    147         elsif (@sp == 1) 
    148         { 
     145        } elsif (@sp == 1) { 
    149146            return $hash->{domain}->{$dom}->{node}->{$host}->{$sp[0]}; 
    150         } 
    151         else 
    152         { 
     147        } else { 
    153148            warn "munin_set_var: Malformatted variable path \"$var\"."; 
    154149        } 
    155     } 
    156     elsif ($var =~ /^\s*([^;:]+);([^;:]+)\s*$/) 
    157     { 
     150    } elsif ($var =~ /^\s*([^;:]+);([^;:]+)\s*$/) { 
    158151        my ($dom, $rest) = ($1, $2); 
    159152        my @sp = split (/\./, $rest); 
    160153 
    161         if (@sp == 1) 
    162         { 
     154        if (@sp == 1) { 
    163155            return $hash->{domain}->{$dom}->{$sp[0]}; 
    164         } 
    165         else 
    166         { 
     156        } else { 
    167157            warn "munin_set_var: Malformatted variable path \"$var\"."; 
    168158        } 
    169     } 
    170     elsif ($var =~ /^\s*([^;:\.]+)\s*$/) 
    171     { 
     159    } elsif ($var =~ /^\s*([^;:\.]+)\s*$/) { 
    172160        return $hash->{$1}; 
    173     } 
    174     else 
    175     { 
     161    } else { 
    176162        warn "munin_set_var: Malformatted variable path \"$var\"."; 
    177163    } 
    …… 
    186172 
    187173    print "DEBUG: Setting var \"$var\" = \"$val\"\n" if $::DEBUG; 
    188     if ($var =~ /^\s*([^;:]+);([^:]+):(\S+)\s*$/) 
    189     { 
     174    if ($var =~ /^\s*([^;:]+);([^:]+):(\S+)\s*$/) { 
    190175        my ($dom, $host, $rest) = ($1, $2, $3); 
    191176        my @sp = split (/\./, $rest); 
    192177 
    193         if (@sp == 3) 
    194         { 
     178        if (@sp == 3) { 
    195179            ::logger ("Warning: Unknown option \"$sp[2]\" in \"$dom;$host:$sp[0].$sp[1].$sp[2]\".") 
    196180                unless defined $legal_expanded{$sp[2]}; 
    197181            $hash->{domain}->{$dom}->{node}->{$host}->{client}->{$sp[0]}->{"$sp[1].$sp[2]"} = $val; 
    198         } 
    199         elsif (@sp == 2) 
    200         { 
     182        } elsif (@sp == 2) { 
    201183            ::logger ("Warning: Unknown option \"$sp[1]\" in \"$dom;$host:$sp[0].$sp[1]\".") 
    202184                unless defined $legal_expanded{$sp[1]}; 
    203185            $hash->{domain}->{$dom}->{node}->{$host}->{client}->{$sp[0]}->{$sp[1]} = $val; 
    204         } 
    205         elsif (@sp == 1) 
    206         { 
     186        } elsif (@sp == 1) { 
    207187            ::logger ("Warning: Unknown option \"$sp[0]\" in \"$dom;$host:$sp[0]\".") 
    208188                unless defined $legal_expanded{$sp[0]}; 
    209189            $hash->{domain}->{$dom}->{node}->{$host}->{$sp[0]} = $val; 
    210         } 
    211         else 
    212         { 
     190        } else { 
    213191            warn "munin_set_var: Malformatted variable path \"$var\"."; 
    214192        } 
    215     } 
    216     elsif ($var =~ /^\s*([^;:]+);([^;:]+)\s*$/) 
    217     { 
     193    } elsif ($var =~ /^\s*([^;:]+);([^;:]+)\s*$/) { 
    218194        my ($dom, $rest) = ($1, $2); 
    219195        my @sp = split (/\./, $rest); 
    220196 
    221         if (@sp == 1) 
    222         { 
     197        if (@sp == 1) { 
    223198            ::logger ("Warning: Unknown option \"$sp[0]\" in \"$dom;$sp[0]\".") 
    224199                unless defined $legal_expanded{$sp[0]}; 
    225200            $hash->{domain}->{$dom}->{$sp[0]} = $val; 
    226         } 
    227         else 
    228         { 
     201        } else { 
    229202            warn "munin_set_var: Malformatted variable path \"$var\"."; 
    230203        } 
    231     } 
    232     elsif ($var =~ /^\s*([^;:\.]+)\s*$/) 
    233     { 
     204    } elsif ($var =~ /^\s*([^;:\.]+)\s*$/) { 
    234205        ::logger ("Warning: Unknown option \"$1\" in \"$1\".") 
    235206            unless defined $legal_expanded{$1}; 
    236207        $hash->{$1} = $val; 
    237     } 
    238     elsif ($var =~ /^\s*([^\.]+)\.([^\.]+)\.([^\.]+)$/) 
    239     { 
     208    } elsif ($var =~ /^\s*([^\.]+)\.([^\.]+)\.([^\.]+)$/) { 
    240209        ::logger ("Warning: Unknown option \"$1\" in \"$var\".") 
    241210            unless defined $legal_expanded{$1}; 
    …… 
    243212            unless defined $legal_expanded{$3}; 
    244213        $hash->{$1}->{$2}->{$3} = $val; 
    245     } 
    246     else 
    247     { 
     214    } else { 
    248215        warn "munin_set_var: Malformatted variable path \"$var\"."; 
    249216    } 
    …… 
    257224 
    258225    # Write datafile 
    259     foreach my $a (keys %{$data}) 
    260     { 
    261         if (ref ($data->{$a}) eq "HASH") 
    262         { 
    263             if ($a eq "domain" or $a eq "node" or $a eq "client") 
    264             { 
     226    foreach my $a (keys %{$data}) { 
     227        if (ref ($data->{$a}) eq "HASH") { 
     228            if ($a eq "domain" or $a eq "node" or $a eq "client") { 
    265229                &munin_writeconfig_loop ($data->{$a}, $fh, "$pre"); 
    266             } 
    267             elsif ($a eq "contact" and $pre eq "") 
    268             { 
     230            } elsif ($a eq "contact" and $pre eq "") { 
    269231                &munin_writeconfig_loop ($data->{$a}, $fh, "contact."); 
    270             } 
    271             else 
    272             { 
     232            } else { 
    273233                my $lpre = $pre; 
    274                 if ($lpre eq "") 
    275                 { 
     234                if ($lpre eq "") { 
    276235                    $lpre = $a.";"; 
    277                 } 
    278                 elsif ($lpre =~ /;$/) 
    279                 { 
     236                } elsif ($lpre =~ /;$/) { 
    280237                    $lpre .= $a.":"; 
    281                 } 
    282                 else 
    283                 { 
     238                } else { 
    284239                    $lpre .= $a."."; 
    285240                } 
    286241                &munin_writeconfig_loop ($data->{$a}, $fh, "$lpre"); 
    287242            } 
    288         } 
    289         elsif (defined $data->{$a} and length $data->{$a}) 
    290         { 
     243        } elsif (defined $data->{$a} and length $data->{$a}) { 
    291244            next if "$pre$a" eq "version"; # Handled separately 
    292245            print "Writing: $pre$a $data->{$a}\n" if $::DEBUG; 
    293             if ($data->{$a} =~ /\\$/) 
    294             { # Backslash as last char has special meaning. Avoid it. 
    295                 print $fh "$pre$a $data->{$a}\\\n";  
     246            if ($data->{$a} =~ /\\$/) { 
     247               # Backslash as last char has special meaning. Avoid it. 
     248                print $fh "$pre$a $data->{$a}\\\n"; 
    296249            } else { 
    297250                print $fh "$pre$a $data->{$a}\n"; 
    …… 
    307260#   $datafile->save_file($datafilename,$data); 
    308261 
    309     if (!defined $fh) 
    310     { 
     262    if (!defined $fh) { 
    311263        $fh = gensym(); 
    312         unless (open ($fh, ">$datafilename")) 
    313         { 
    314             die "Fatal error: Could not open \"$datafilename\" for writing: $!"; 
     264        die "Fatal error: Could not open \"$datafilename\" for writing: $!" 
     265          unless open ($fh, ">$datafilename"); 
    315266        } 
    316267    } 
    …… 
    321272    &munin_writeconfig_loop ($data, $fh, ""); 
    322273 
    323     if (defined $fh) 
    324     { 
     274    if (defined $fh) { 
    325275        print "DEBUG: Closing filehandle \"$datafilename\"...\n" 
    326276          if $::DEBUG; 
    …… 
    328278    } 
    329279} 
     280 
    330281 
    331282sub munin_config ($$) { 
    …… 
    341292} 
    342293 
     294sub munin_fetch { 
     295    # Fetch data from a rrd file. 
     296    my ($file,$last,$type) = @_; 
     297    my ($start,$step,$names,$data) = RRDs::fetch $file,$type || "AVERAGE"; 
     298    if (!defined $data) { 
     299        ::logger ("Could not fetch data from $file(".($type||"AVERAGE")."): ". RRDs::error); 
     300        return undef; 
     301    } 
     302    my @array = map { @$_[0] } splice(@$data, $#$data - ($last || 1)); 
     303    return $array[0] if (!$last); 
     304    return @array; 
     305} 
     306 
     307 
     308sub munin_draw_field { 
     309    my $node    = shift; 
     310    my $service = shift; 
     311    my $field   = shift; 
     312 
     313    $field =~ s/=.*//; 
     314 
     315    print "DEBUG: munin_draw_field: Checking $service -> $field: " . 
     316      &munin_get_bool_val ($node->{client}->{$service}->{$field.".graph"}, 1). 
     317        ".\n" if $::DEBUG;; 
     318    return 0 if (exists $node->{client}->{$service}->{$field.".skipdraw"}); 
     319    return &munin_get_bool_val($node->{client}->{$service}->{$field.".graph"}, 
     320                               1); 
     321} 
     322 
     323 
     324 
     325sub munin_nscasend { 
     326    my ($name,$service,$label,$level,$comment) = @_; 
     327 
     328    if (!$nsca->opened) { 
     329        open ($nsca ,"|$config->{nsca} $config->{nsca_server} -c $config->{nsca_config} -to 60"); 
     330    } 
     331    if ($label) { 
     332        print $nsca  "$name\t$service: $label\t$level\t$comment\n"; 
     333        print ("$name;$service: $label;$level;$comment\n") if $::DEBUG; 
     334    } else { 
     335        print $nsca  "$name\t$service\t$level\t$comment\n"; 
     336        print ("$name;$service;$level;$comment\n") if $::DEBUG; 
     337    } 
     338} 
     339 
     340 
     341sub munin_trend { 
     342    # ??? 
     343    # This function seems to be unused. 
     344    my (@array) = @_; 
     345    return ($array[$#array] - $array[0]); 
     346} 
     347 
     348 
    3433491;