Changeset 1255

Show
Ignore:
Timestamp:
11/18/06 02:10:32 (5 years ago)
Author:
janl
Message:

Think Munin.pm is free of server only functions now. Keeping the config handling ones as nodes will probably have to be more configured soon.

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved
  • people/janl/src/libperl/Munin.pm

    r1254 r1255  
    11package Munin; 
    2  
    32# 
    43# Copyright (C) 2003-2006 Jimmy Olsen, Audun Ytterdal, Nicolai Langfeldt 
     
    4645my $configfile = '@@CONFDIR@@/munin.conf'; 
    4746@legalfetch  = qw(.value); 
    48 @legalconfig = qw( 
    49   graph_order graph_title create_args graph_args 
    50   graph_vlabel graph_vtitle graph_total graph_scale graph 
    51   update host_name 
    52   .label .cdef .draw .graph .max .min .negative 
    53   .skipdraw .type .warning .critical .colour 
    54   .graph_printf 
    55   ); 
     47@legalconfig = qw(graph_order graph_title create_args graph_args 
     48                  graph_vlabel graph_vtitle graph_total graph_scale graph 
     49                  update host_name 
     50                   
     51                  .label .cdef .draw .graph .max .min .negative 
     52                  .skipdraw .type .warning .critical .colour 
     53                  .graph_printf ); 
    5654 
    5755# Fields to copy when "aliasing" a field 
     
    6159my $PREFIX = '@@PREFIX@@'; 
    6260$ENV{'MUNIN_PREFIX'} = $PREFIX; 
    63 $CONFDIR = '@@CONFDIR@@';    # /etc/munin,/etc/opt/munin or such 
     61$CONFDIR = '@@CONFDIR@@';               # /etc/munin,/etc/opt/munin or such 
    6462print "CONFDIR: $CONFDIR!\n"; 
    6563$ENV{'MUNIN_CONFDIR'} = $CONFDIR; 
     
    7068my $DOCDIR = '@@DOCDIR@@'; 
    7169$ENV{'MUNIN_DOCDIR'} = $DOCDIR; 
    72 my $LIBDIR = '@@LIBDIR@@';    # LIBDIR/plugins contains plugin.sh 
     70my $LIBDIR = '@@LIBDIR@@';              # LIBDIR/plugins contains plugin.sh 
    7371$ENV{'MUNIN_LIBDIR'} = $LIBDIR; 
    7472my $HTMLDIR = '@@HTMLDIR@@'; 
     
    7876my $DBDIR = '@@DBDIR@@'; 
    7977$ENV{'MUNIN_DBDIR'} = $DBDIR; 
    80 my $PLUGSTATE = '@@PLUGSTATE@@';    # Put plugin state files here! 
    81 $ENV{'MUNIN_PLUGSTATE'} = $PLUGSTATE;    # Put plugin state files here! 
     78my $PLUGSTATE = '@@PLUGSTATE@@';        # Put plugin state files here! 
     79$ENV{'MUNIN_PLUGSTATE'} = $PLUGSTATE;   # Put plugin state files here! 
    8280my $MANDIR = '@@MANDIR@@'; 
    8381$ENV{'MUNIN_MANDIR'} = $MANDIR; 
     
    8583$ENV{'MUNIN_LOGDIR'} = $LOGDIR; 
    8684my $STATEDIR = '@@STATEDIR@@';           # This is for .pid files 
    87 $ENV{'MUNIN_STATEDIR'} = $STATEDIR;      # This is for .pid files 
     85$ENV{'MUNIN_STATEDIR'} = $STATEDIR;  
    8886my $USER = '@@USER@@';                   # User munin runs as (mostly) 
    89 $ENV{'MUNIN_USER'} = $USER;              # User munin runs as (mostly) 
     87$ENV{'MUNIN_USER'} = $USER; 
    9088my $GROUP = '@@GROUP@@';                 # Group ditto 
    91 $ENV{'MUNIN_GROUP'} = $GROUP;            # Group ditto 
     89$ENV{'MUNIN_GROUP'} = $GROUP; 
    9290my $PLUGINUSER = '@@PLUGINUSER@@';       # Default user for plugin running 
    93 $ENV{'MUNIN_PLUGINUSER'} = $PLUGINUSER;  # Default user for plugin running 
     91$ENV{'MUNIN_PLUGINUSER'} = $PLUGINUSER; 
    9492$ENV{'MUNIN_VERSION'}    = $VERSION; 
    9593my $PERL = '@@PERL@@'; 
     
    111109 
    112110sub munin_createlock { 
    113  
    114111    # Create lock file, fail and die if not possible. 
     112     
    115113    my ($lockname) = @_; 
    116114    if ( sysopen( LOCK, $lockname, O_WRONLY | O_CREAT | O_EXCL ) ) { 
     
    125123 
    126124sub munin_removelock { 
    127  
    128125    # Remove lock or die trying. 
     126     
    129127    my ($lockname) = @_; 
    130128    unlink $lockname 
     
    133131 
    134132sub munin_runlock { 
    135  
    136133    # Simple get lock: Get lock or die trying 
     134     
    137135    my ($lockname) = @_; 
    138136    unless ( &munin_getlock($lockname) ) { 
     
    143141} 
    144142 
     143 
    145144sub munin_getlock { 
    146  
    147145    # Complicated get lock: Try getting it, if it's taken see if the 
    148146    # invoking process is still alive. 
    149147    my ($lockname) = @_; 
    150148    if ( -f $lockname ) { 
    151  
    152149        # Is the lockpid alive? 
    153150        # To check this is inteligent and so on.  It also makes for a 
     
    172169} ## end sub munin_getlock 
    173170 
    174 sub munin_delete { 
    175     # Delete a domain, and corresponding set of nodes from config tree 
    176     my ( $config, $data ) = @_; 
    177     for my $domain ( keys %{ $data->{domain} } ) { 
    178         if ( !$config->{domain}->{$domain} ) { 
    179             ::logger("Removing domain: $domain"); 
    180             delete( $data->{domain}->{$domain} ); 
    181             next; 
    182         } 
    183         for my $node ( keys %{ $data->{domain}->{$domain}->{node} } ) { 
    184             unless ( $config->{domain}->{$domain}->{node}->{$node} ) { 
    185                 ::logger("Removing node from $domain: $node"); 
    186                 delete( $data->{domain}->{$domain}->{node}->{$node} ); 
    187             } 
    188         } 
    189     } 
    190     return ($data); 
    191 } 
    192171 
    193172sub munin_overwrite { 
     
    224203} ## end sub munin_get_picture_filename 
    225204 
    226 sub munin_get_filename { 
    227     my ( $config, $domain, $node, $service, $field ) = @_; 
    228     return ( 
    229         $config->{'dbdir'} . "/$domain/$node-$service-$field-" 
    230           . lc substr( 
    231             ( 
    232                 $config->{domain}->{$domain}->{node}->{$node}->{client} 
    233                   ->{$service}->{ $field . ".type" } || "GAUGE" 
    234             ), 
    235             0, 1 
    236           ) 
    237           . ".rrd" 
    238     ); 
    239 } 
    240205 
    241206sub munin_get_bool { 
     207    # Like munin_get but interpret the value as a boolean value. 
    242208    my $conf    = shift; 
    243209    my $field   = shift; 
     
    274240} ## end sub munin_get_bool 
    275241 
     242 
    276243sub munin_get_bool_val { 
     244    # Interpret some string as a boolean value. 
    277245    my $field   = shift; 
    278246    my $default = shift; 
     
    306274} ## end sub munin_get_bool_val 
    307275 
     276 
    308277sub munin_get { 
    309  
    310278    # Fetch value from configuration tree.  Start at deepest level and 
    311279    # "recurse" upwards.  This allows defaulting at shalow levels and 
    312280    # specific overrides at deeper levels. 
     281     
    313282    my $conf    = shift; 
    314283    my $field   = shift; 
     
    318287    my $service = shift; 
    319288    my $plot    = shift; 
     289     
    320290    if ( defined $field ) { 
    321         return $conf->{domain}->{$domain}->{node}->{$node}->{client}->{$service} 
    322           ->{"$plot.$field"} 
    323           if ( 
    324             defined $domain 
    325             and defined $node 
    326             and defined $service 
    327             and defined $plot 
    328             and defined $conf->{domain}->{$domain}->{node}->{$node}->{client} 
    329             ->{$service}->{"$plot.$field"} ); 
    330         return $conf->{domain}->{$domain}->{node}->{$node}->{client}->{$service} 
    331           ->{$field} 
    332           if ( 
    333             defined $domain 
    334             and defined $node 
    335             and defined $service 
    336             and defined $conf->{domain}->{$domain}->{node}->{$node}->{client} 
    337             ->{$service}->{$field} ); 
     291        return $conf->{domain}->{$domain}->{node}->{$node}->{client}-> 
     292            {$service}->{"$plot.$field"} 
     293             
     294          if (defined $domain and 
     295              defined $node and 
     296              defined $service and 
     297              defined $plot and 
     298              defined($conf->{domain}->{$domain}->{node}->{$node}->{client}-> 
     299                      {$service}->{"$plot.$field"}) ); 
     300                       
     301        return $conf->{domain}->{$domain}->{node}->{$node}->{client}-> 
     302            {$service}->{$field} 
     303          if (defined $domain and 
     304              defined $node and 
     305              defined $service and 
     306              defined($conf->{domain}->{$domain}->{node}->{$node}->{client}-> 
     307                      {$service}->{$field}) ); 
     308                       
    338309        return $conf->{domain}->{$domain}->{node}->{$node}->{$field} 
    339           if ( 
    340             defined $domain 
    341             and defined $node 
    342             and defined $conf->{domain}->{$domain}->{node}->{$node}->{$field} ); 
     310          if (defined $domain and 
     311              defined $node and 
     312              defined($conf->{domain}->{$domain}->{node}->{$node}->{$field}) ); 
     313               
    343314        return $conf->{domain}->{$domain}->{$field} 
    344           if ( 
    345             defined $domain 
    346             and defined $conf->{domain}->{$domain}->{$field} ); 
     315          if (defined $domain and 
     316              defined $conf->{domain}->{$domain}->{$field} ); 
     317               
    347318        return $conf->{$field} 
    348319          if ( defined $conf->{$field} ); 
     320           
    349321        return $default; 
    350     } else { 
     322         
     323    } else { 
     324         
    351325        return $conf->{domain}->{$domain}->{node}->{$node}->{client}->{$service} 
    352           if ( 
    353             defined $domain 
    354             and defined $node 
    355             and defined $service 
    356             and defined $conf->{domain}->{$domain}->{node}->{$node}->{client} 
    357             ->{$service} ); 
     326          if (defined $domain and 
     327              defined $node and 
     328              defined $service and 
     329              defined($conf->{domain}->{$domain}->{node}->{$node}->{client}-> 
     330                    {$service}) ); 
     331                     
    358332        return $conf->{domain}->{$domain}->{node}->{$node} 
    359           if ( 
    360             defined $domain 
    361             and defined $node 
    362             and defined $conf->{domain}->{$domain}->{node}->{$node} ); 
     333          if (defined $domain and 
     334              defined $node and 
     335              defined $conf->{domain}->{$domain}->{node}->{$node} ); 
     336               
    363337        return $conf->{domain}->{$domain} 
    364           if ( 
    365             defined $domain 
    366             and defined $conf->{domain}->{$domain} ); 
    367         return $conf 
    368           if ( defined $conf ); 
     338          if (defined $domain and 
     339              defined $conf->{domain}->{$domain} ); 
     340 
     341        return $conf if ( defined $conf ); 
     342         
    369343        return $default; 
    370344    } ## end else [ if ( defined $field ) 
    371345} ## end sub munin_get 
    372346 
    373 sub munin_node_status { 
    374     my ( $config, $limits, $domain, $node, $check_draw ) = @_; 
    375     my $state = "ok"; 
    376     return undef unless defined $config->{domain}->{$domain}->{node}->{$node}; 
    377     my $snode = $config->{domain}->{$domain}->{node}->{$node}; 
    378     foreach my $service ( keys %{$snode} ) { 
    379         my $fres = 
    380           &munin_service_status( 
    381             $config, $limits, $domain, $node, $service, 
    382             $check_draw ); 
    383         if ( defined $fres ) { 
    384             if ( $fres eq "critical" ) { 
    385                 $state = $fres; 
    386                 last; 
    387             } elsif ( $fres eq "warning" ) { 
    388                 $state = $fres; 
    389             } 
    390         } 
    391     } 
    392     return $state; 
    393 } ## end sub munin_node_status 
    394  
    395 sub munin_category_status { 
    396     my ( $config, $limits, $domain, $node, $category, $check_draw ) = @_; 
    397     my $state = "ok"; 
    398     return undef unless defined $config->{domain}->{$domain}->{node}->{$node}; 
    399     my $snode = $config->{domain}->{$domain}->{node}->{$node}; 
    400     foreach my $service ( keys %{ $snode->{client} } ) { 
    401         next 
    402           if ( 
    403             ( not defined $snode->{client}->{$service}->{graph_category} ) 
    404             and $category ne 'other' ); 
    405         next 
    406           if ( 
    407             ( defined $snode->{client}->{$service}->{graph_category} ) 
    408             and ( $snode->{client}->{$service}->{graph_category} ne $category ) 
    409           ); 
    410         my $fres = 
    411           &munin_service_status( 
    412             $config, $limits, $domain, $node, $service, 
    413             $check_draw ); 
    414         if ( defined $fres ) { 
    415             if ( $fres eq "critical" ) { 
    416                 $state = $fres; 
    417                 last; 
    418             } elsif ( $fres eq "warning" ) { 
    419                 $state = $fres; 
    420             } 
    421         } 
    422     } ## end foreach my $service ( keys ... 
    423     return $state; 
    424 } ## end sub munin_category_status 
    425  
    426 sub munin_service_status { 
    427     my ( $config, $limits, $domain, $node, $service, $check_draw ) = @_; 
    428     my $state = "ok"; 
    429     return undef 
    430       unless defined $config->{domain}->{$domain}->{node}->{$node}->{client} 
    431       ->{$service}; 
    432     foreach my $key ( 
    433         keys 
    434         %{ $config->{domain}->{$domain}->{node}->{$node}->{client}->{$service} } 
    435       ) 
    436     { 
    437         next unless $key =~ /^([^\.]+)\.label$/; 
    438         my $field = $1; 
    439         my $fres  = 
    440           &munin_field_status( 
    441             $config, $limits, $domain, $node, $service, 
    442             $field, $check_draw ); 
    443         if ( defined $fres ) { 
    444             if ( $fres eq "critical" ) { 
    445                 $state = $fres; 
    446                 last; 
    447             } elsif ( $fres eq "warning" ) { 
    448                 $state = $fres; 
    449             } 
    450         } 
    451     } ## end foreach my $key ( keys %{ $config... 
    452     return $state; 
    453 } ## end sub munin_service_status 
    454  
    455 sub munin_field_status { 
    456  
    457     # Something to do with warning and critical levels. 
    458     # Appears to not set warning/critical state if "nagios" is turned 
    459     # off.  Isn't that a bit odd? 
    460     my ( $config, $limits, $domain, $node, $service, $field, $check_draw ) = @_; 
    461     my $state = undef; 
    462  
    463     # Return undef if nagios is turned off, or the field doesn't have any limits 
    464     unless ( 
    465         ( 
    466             defined $config->{domain}->{$domain}->{node}->{$node}->{client} 
    467             ->{$service}->{"$field.warning"} 
    468         ) 
    469         or ( 
    470             defined $config->{domain}->{$domain}->{node}->{$node}->{client} 
    471             ->{$service}->{"$field.critical"} ) 
    472       ) 
    473     { 
    474         return undef; 
    475     } 
    476     if ( 
    477         defined $limits->{domain}->{$domain}->{node}->{$node}->{client} 
    478         ->{$service}->{"$field.critical"} 
    479         and ( 
    480             !defined $check_draw 
    481             or !$check_draw 
    482             or &munin_draw_field( 
    483                 $config->{domain}->{$domain}->{node}->{$node}, 
    484                 $service, $field 
    485             ) 
    486         ) 
    487        ) 
    488     { 
    489         return "critical"; 
    490     } 
    491     elsif ( 
    492         defined $limits->{domain}->{$domain}->{node}->{$node}->{client} 
    493         ->{$service}->{"$field.warning"} 
    494         and ( 
    495             !defined $check_draw 
    496             or !$check_draw 
    497             or &munin_draw_field( 
    498                 $config->{domain}->{$domain}->{node}->{$node}, 
    499                 $service, $field 
    500             ) 
    501         ) 
    502       ) 
    503     { 
    504         return "warning"; 
    505     } else { 
    506         return "ok"; 
    507     } 
    508 } ## end sub munin_field_status 
    509  
    510 sub munin_graph_column_headers { 
    511     my ( $config, $domain, $node, $serv ) = @_; 
    512     my $ret    = 0; 
    513     my @fields = (); 
    514     foreach my $field ( 
    515         keys 
    516         %{ $config->{domain}->{$domain}->{node}->{$node}->{client}->{$serv} } ) 
    517     { 
    518         if ( 
    519             $field =~ /^([^\.]+)\.negative$/ 
    520             and munin_draw_field( 
    521                 $config->{domain}->{$domain}->{node}->{$node}, 
    522                 $serv, $1 
    523             ) 
    524            ) 
    525         { 
    526             return 1; 
    527         } 
    528         elsif ( 
    529             $field =~ /^([^\.]+)\.label$/ 
    530             and munin_draw_field( 
    531                 $config->{domain}->{$domain}->{node}->{$node}, 
    532                 $serv, $1 
    533             ) 
    534           ) 
    535         { 
    536             push @fields, $1; 
    537         } 
    538     } ## end foreach my $field ( keys %{... 
    539     return 1 
    540       if ( 
    541         munin_get_max_label_length( 
    542             $config->{'domain'}->{$domain}->{'node'}->{$node}, 
    543             $config, $domain, $node, $serv, \@fields 
    544         ) > 20 
    545       ); 
    546     return $ret; 
    547 } ## end sub munin_graph_column_headers 
    548  
    549 sub munin_get_max_label_length { 
    550     my $node    = shift; 
    551     my $config  = shift; 
    552     my $domain  = shift; 
    553     my $host    = shift; 
    554     my $service = shift; 
    555     my $order   = shift; 
    556     my $result  = 0; 
    557     for my $field (@$order) { 
    558         my $path = undef; 
    559         ( my $f = $field ) =~ s/=.+//; 
    560         next 
    561           if ( 
    562             exists $node->{client}->{$service}->{ $f . ".process" } 
    563             and $node->{client}->{$service}->{ $f . ".process" } ne "yes" ); 
    564         next if ( exists $node->{client}->{$service}->{ $f . ".skipdraw" } ); 
    565         next 
    566           unless ( 
    567             !exists $node->{client}->{$service}->{ $f . ".graph" } 
    568             or $node->{client}->{$service}->{ $f . ".graph" } eq "yes" ); 
    569         if ($result < 
    570             length( $node->{client}->{$service}->{ $f . ".label" } || $f ) ) 
    571         { 
    572             $result = 
    573               length( $node->{client}->{$service}->{ $f . ".label" } || $f ); 
    574         } 
    575         if (exists $node->{client}->{$service}->{graph_total} 
    576             and length $node->{client}->{$service}->{graph_total} > $result ) 
    577         { 
    578             $result = length $node->{client}->{$service}->{graph_total}; 
    579         } 
    580     } ## end for my $field (@$order) 
    581     return $result; 
    582 } ## end sub munin_get_max_label_length 
    583  
    584 sub munin_get_field_order { 
    585     my $node    = shift; 
    586     my $config  = shift; 
    587     my $domain  = shift; 
    588     my $host    = shift; 
    589     my $service = shift; 
    590     my $result  = []; 
    591     if ( $node->{client}->{$service}->{graph_sources} ) { 
    592         foreach 
    593           my $gs ( split /\s+/, $node->{client}->{$service}->{'graph_sources'} ) 
    594         { 
    595             push( @$result, "-" . $gs ); 
    596         } 
    597     } 
    598     if ( $node->{client}->{$service}->{graph_order} ) { 
    599         push( 
    600             @$result, 
    601             split /\s+/, $node->{client}->{$service}->{'graph_order'} ); 
    602     } 
    603     for my $key ( keys %{ $node->{client}->{$service} } ) { 
    604         my ( $client, $type ) = ""; 
    605         ( $client, $type ) = split /\./, $key; 
    606         if ( defined $type and $type eq "label" ) { 
    607             push @$result, $client if !grep /^\Q$client\E(?:=|$)/, @$result; 
    608         } 
    609     } 
    610     return $result; 
    611 } ## end sub munin_get_field_order 
    612  
    613 sub munin_get_rrd_filename { 
    614     my $node    = shift; 
    615     my $config  = shift; 
    616     my $domain  = shift; 
    617     my $name    = shift; 
    618     my $service = shift; 
    619     my $field   = shift; 
    620     my $path    = shift; 
    621     my $result  = "unknown"; 
    622     if ( $node->{client}->{$service}->{ $field . ".filename" } ) { 
    623         $result = $node->{client}->{$service}->{ $field . ".filename" }; 
    624     } elsif ($path) { 
    625         if ( !defined( $node->{client}->{$service}->{ $field . ".label" } ) ) { 
    626             print "DEBUG: Setting label: $field\n" if $DEBUG; 
    627             $node->{client}->{$service}->{ $field . ".label" } = $field; 
    628         } 
    629         if ( $path =~ /^\s*([^:;]+)[:;]([^:]+):([^:\.]+)[:\.]([^:\.]+)\s*$/ ) { 
    630             $result = munin_get_filename( $config, $1, $2, $3, $4 ); 
    631             print "\nDEBUG1: Expanding $path...\n" if $DEBUG; 
    632             if ( !defined $node->{client}->{$service}->{ $field . "label" } ) { 
    633                 for my $f (@copy_fields) { 
    634                     if (not exists $node->{client}->{$service}->{"$field.$f"} 
    635                         and exists $config->{'domain'}->{$1}->{'node'}->{$2} 
    636                         ->{'client'}->{$3}->{"$4.$f"} ) 
    637                     { 
    638                         $node->{client}->{$service}->{"$field.$f"} = 
    639                           $config->{'domain'}->{$1}->{'node'}->{$2}->{'client'} 
    640                           ->{$3}->{"$4.$f"}; 
    641                     } 
    642                 } 
    643             } 
    644         } elsif ( $path =~ /^\s*([^:]+):([^:\.]+)[:\.]([^:\.]+)\s*$/ ) { 
    645             print "\nDEBUG2: Expanding $path...\n" if $DEBUG; 
    646             $result = munin_get_filename( $config, $domain, $1, $2, $3 ); 
    647             for my $f (@copy_fields) { 
    648                 if (not exists $node->{client}->{$service}->{"$field.$f"} 
    649                     and exists $config->{'domain'}->{$domain}->{'node'}->{$1} 
    650                     ->{'client'}->{$2}->{"$3.$f"} ) 
    651                 { 
    652                     print "DEBUG: Copying $f...\n" if $DEBUG; 
    653                     $node->{client}->{$service}->{"$field.$f"} = 
    654                       $config->{'domain'}->{$domain}->{'node'}->{$1}->{'client'} 
    655                       ->{$2}->{"$3.$f"}; 
    656                 } 
    657             } 
    658         } elsif ( $path =~ /^\s*([^:\.]+)[:\.]([^:\.]+)\s*$/ ) { 
    659             print "\nDEBUG3: Expanding $path...\n" if $DEBUG; 
    660             $result = munin_get_filename( $config, $domain, $name, $1, $2 ); 
    661             for my $f (@copy_fields) { 
    662                 if (not exists $node->{client}->{$service}->{"$field.$f"} 
    663                     and exists $node->{client}->{$1}->{"$2.$f"} ) 
    664                 { 
    665                     $node->{client}->{$service}->{"$field.$f"} = 
    666                       $node->{client}->{$1}->{"$2.$f"}; 
    667                 } 
    668             } 
    669         } elsif ( $path =~ /^\s*([^:\.]+)\s*$/ ) { 
    670             print "\nDEBUG4: Expanding $path...\n" if $DEBUG; 
    671             $result = 
    672               munin_get_filename( $config, $domain, $name, $service, $1 ); 
    673             for my $f (@copy_fields) { 
    674                 if (not exists $node->{client}->{$service}->{"$field.$f"} 
    675                     and exists $node->{client}->{$service}->{"$1.$f"} ) 
    676                 { 
    677                     $node->{client}->{$service}->{"$field.$f"} = 
    678                       $node->{client}->{$service}->{"$1.$f"}; 
    679                 } 
    680             } 
    681         } 
    682     } else { 
    683         print "\nDEBUG5: Doing path...\n" if $DEBUG; 
    684         $result = 
    685           munin_get_filename( $config, $domain, $name, $service, $field ); 
    686     } 
    687     return $result; 
    688 } ## end sub munin_get_rrd_filename 
     347 
     348# Return true to mark successful inclusion of module. 
    6893491; 
    690350 
  • people/janl/src/libperl/Munin/Server.pm

    r1252 r1255  
    1212 
    1313@EXPORT = qw( 
    14  
    1514             $configfile @legal %legal_expanded @copy_fields 
    1615             munin_readconfig munin_parse_config munin_trend 
    1716             munin_fetch munin_nscasend 
    18  
    1917            ); 
    2018 
     
    3432            category_order version tls_certificate tls_private_key 
    3533            tls_pem tls_verify_certificate tls_verify_depth 
    36             graph_data_size); 
     34            graph_data_size 
     35           ); 
    3736 
    3837push(@legal,@Munin::legalfetch,@Munin::legalconfig); 
     
    128127} 
    129128 
     129 
    130130sub munin_get_var_path 
    131131{ 
     
    165165    return undef; 
    166166} 
     167 
    167168 
    168169sub munin_set_var_path { 
     
    218219    return $hash; 
    219220} 
     221 
    220222 
    221223sub munin_writeconfig_loop { 
     
    264266        die "Fatal error: Could not open \"$datafilename\" for writing: $!" 
    265267          unless open ($fh, ">$datafilename"); 
    266         } 
    267268    } 
    268269 
     
    292293} 
    293294 
     295 
    294296sub munin_fetch { 
    295297    # Fetch data from a rrd file. 
     
    297299    my ($start,$step,$names,$data) = RRDs::fetch $file,$type || "AVERAGE"; 
    298300    if (!defined $data) { 
    299         ::logger ("Could not fetch data from $file(".($type||"AVERAGE")."): ". RRDs::error); 
     301        ::logger ("Could not fetch data from $file(".($type||"AVERAGE")."): ". 
     302            RRDs::error); 
    300303        return undef; 
    301304    } 
     
    322325 
    323326 
    324  
    325327sub munin_nscasend { 
    326328    my ($name,$service,$label,$level,$comment) = @_; 
    327329 
    328     if (!$nsca->opened) { 
    329         open ($nsca ,"|$config->{nsca} $config->{nsca_server} -c $config->{nsca_config} -to 60"); 
     330    if (!$::nsca->opened) { 
     331        open ($::nsca ,"|$::config->{nsca} ". 
     332                     "$::config->{nsca_server} ". 
     333                     "-c $::config->{nsca_config} -to 60"); 
    330334    } 
    331335    if ($label) { 
    332         print $nsca  "$name\t$service: $label\t$level\t$comment\n"; 
     336        print $::nsca  "$name\t$service: $label\t$level\t$comment\n"; 
    333337        print ("$name;$service: $label;$level;$comment\n") if $::DEBUG; 
    334338    } else { 
    335         print $nsca  "$name\t$service\t$level\t$comment\n"; 
     339        print $::nsca  "$name\t$service\t$level\t$comment\n"; 
    336340        print ("$name;$service;$level;$comment\n") if $::DEBUG; 
    337341    } 
     
    347351 
    348352 
     353sub munin_delete { 
     354    # Delete a domain, and corresponding set of nodes from config tree 
     355    my ( $config, $data ) = @_; 
     356    for my $domain ( keys %{ $data->{domain} } ) { 
     357        if ( !$config->{domain}->{$domain} ) { 
     358            ::logger("Removing domain: $domain"); 
     359            delete( $data->{domain}->{$domain} ); 
     360            next; 
     361        } 
     362        for my $node ( keys %{ $data->{domain}->{$domain}->{node} } ) { 
     363            unless ( $config->{domain}->{$domain}->{node}->{$node} ) { 
     364                ::logger("Removing node from $domain: $node"); 
     365                delete( $data->{domain}->{$domain}->{node}->{$node} ); 
     366            } 
     367        } 
     368    } 
     369    return ($data); 
     370} 
     371 
     372 
     373sub munin_get_filename { 
     374    my ( $config, $domain, $node, $service, $field ) = @_; 
     375    return ( 
     376        $config->{'dbdir'} . "/$domain/$node-$service-$field-" 
     377          . lc substr( 
     378                      ($config->{domain}->{$domain}->{node}->{$node}->{client}-> 
     379                       {$service}->{ $field . ".type" } || "GAUGE"), 
     380            0, 1 ) . ".rrd" ); 
     381} 
     382 
     383sub munin_node_status { 
     384    # Return node status.  Does this propagate plugin status to nodes to 
     385    # higher levels? 
     386    # FIXME: Complete documentation if munin_node_status 
     387    my ( $config, $limits, $domain, $node, $check_draw ) = @_; 
     388    my $state = "ok"; 
     389    return undef unless defined $config->{domain}->{$domain}->{node}->{$node}; 
     390    my $snode = $config->{domain}->{$domain}->{node}->{$node}; 
     391    foreach my $service ( keys %{$snode} ) { 
     392        my $fres = 
     393          &munin_service_status( 
     394            $config, $limits, $domain, $node, $service, 
     395            $check_draw ); 
     396        if ( defined $fres ) { 
     397            if ( $fres eq "critical" ) { 
     398                $state = $fres; 
     399                last; 
     400            } elsif ( $fres eq "warning" ) { 
     401                $state = $fres; 
     402            } 
     403        } 
     404    } 
     405    return $state; 
     406} ## end sub munin_node_status 
     407 
     408 
     409sub munin_category_status { 
     410    # Get status of graph category.  Is there any kind of status propagation 
     411    # here? 
     412    # FIXME: Complete documentation of munin_category_status 
     413    my ( $config, $limits, $domain, $node, $category, $check_draw ) = @_; 
     414    my $state = "ok"; 
     415    return undef unless defined $config->{domain}->{$domain}->{node}->{$node}; 
     416    my $snode = $config->{domain}->{$domain}->{node}->{$node}; 
     417    foreach my $service ( keys %{ $snode->{client} } ) { 
     418        next 
     419          if ( 
     420            ( not defined $snode->{client}->{$service}->{graph_category} ) 
     421            and $category ne 'other' ); 
     422        next 
     423          if ( 
     424            ( defined $snode->{client}->{$service}->{graph_category} ) 
     425            and ( $snode->{client}->{$service}->{graph_category} ne $category ) 
     426          ); 
     427        my $fres = 
     428          &munin_service_status( 
     429            $config, $limits, $domain, $node, $service, 
     430            $check_draw ); 
     431        if ( defined $fres ) { 
     432            if ( $fres eq "critical" ) { 
     433                $state = $fres; 
     434                last; 
     435            } elsif ( $fres eq "warning" ) { 
     436                $state = $fres; 
     437            } 
     438        } 
     439    } ## end foreach my $service ( keys ... 
     440    return $state; 
     441} ## end sub munin_category_status 
     442 
     443 
     444sub munin_service_status { 
     445    # Return status of service. 
     446    my ( $config, $limits, $domain, $node, $service, $check_draw ) = @_; 
     447    my $state = "ok"; 
     448    return undef 
     449      unless defined $config->{domain}->{$domain}->{node}->{$node}-> 
     450        {client}->{$service}; 
     451    foreach my $key ( 
     452        keys 
     453        %{$config->{domain}->{$domain}->{node}->{$node}->{client}->{$service}} ) 
     454    { 
     455        next unless $key =~ /^([^\.]+)\.label$/; 
     456        my $field = $1; 
     457        my $fres  = 
     458          &munin_field_status( 
     459            $config, $limits, $domain, $node, $service, 
     460            $field, $check_draw ); 
     461        if ( defined $fres ) { 
     462            if ( $fres eq "critical" ) { 
     463                $state = $fres; 
     464                last; 
     465            } elsif ( $fres eq "warning" ) { 
     466                $state = $fres; 
     467            } 
     468        } 
     469    } ## end foreach my $key ( keys %{ $config... 
     470    return $state; 
     471} ## end sub munin_service_status 
     472 
     473 
     474sub munin_field_status { 
     475    # Something to do with warning and critical levels. 
     476    # Appears to not set warning/critical state if "nagios" is turned 
     477    # off.  Isn't that a bit odd? 
     478    my ( $config, $limits, $domain, $node, $service, $field, $check_draw ) = @_; 
     479    my $state = undef; 
     480 
     481    # Return undef if nagios is turned off, or the field doesn't have any limits 
     482    unless ((defined($config->{domain}->{$domain}->{node}->{$node}->{client}-> 
     483                     {$service}->{"$field.warning"})) or 
     484            (defined($config->{domain}->{$domain}->{node}->{$node}->{client}-> 
     485                    {$service}->{"$field.critical"}))) { 
     486        return undef; 
     487    } 
     488     
     489    if (defined($limits->{domain}->{$domain}->{node}->{$node}->{client}-> 
     490                {$service}->{"$field.critical"}) and 
     491        (!defined $check_draw or 
     492         !$check_draw or 
     493         &munin_draw_field($config->{domain}->{$domain}->{node}->{$node}, 
     494                           $service, $field) 
     495        ) 
     496       ) { 
     497        return "critical"; 
     498    } elsif (defined($limits->{domain}->{$domain}->{node}->{$node}->{client}-> 
     499             {$service}->{"$field.warning"}) and 
     500             (!defined $check_draw or 
     501              !$check_draw or 
     502              &munin_draw_field($config->{domain}->{$domain}->{node}->{$node}, 
     503                                $service, $field) 
     504             ) 
     505            ) { 
     506        return "warning"; 
     507    } else { 
     508        return "ok"; 
     509    } 
     510} ## end sub munin_field_status 
     511 
     512 
     513sub munin_graph_column_headers { 
     514    my ( $config, $domain, $node, $serv ) = @_; 
     515    my $ret    = 0; 
     516    my @fields = (); 
     517    foreach my $field ( 
     518        keys 
     519        %{ $config->{domain}->{$domain}->{node}->{$node}->{client}->{$serv} } ) 
     520    { 
     521        if ($field =~ /^([^\.]+)\.negative$/ and 
     522            munin_draw_field($config->{domain}->{$domain}->{node}->{$node}, 
     523                             $serv, $1)) { 
     524            return 1; 
     525        } elsif ($field =~ /^([^\.]+)\.label$/ and 
     526                 munin_draw_field($config->{domain}->{$domain}->{node}->{$node}, 
     527                                  $serv, $1)) { 
     528            push @fields, $1; 
     529        } 
     530    } 
     531         
     532    return 1 
     533      if ( 
     534        munin_get_max_label_length( 
     535            $config->{'domain'}->{$domain}->{'node'}->{$node}, 
     536            $config, $domain, $node, $serv, \@fields 
     537        ) > 20 
     538      ); 
     539    return $ret; 
     540} ## end sub munin_graph_column_headers 
     541 
     542 
     543sub munin_get_max_label_length { 
     544    my $node    = shift; 
     545    my $config  = shift; 
     546    my $domain  = shift; 
     547    my $host    = shift; 
     548    my $service = shift; 
     549    my $order   = shift; 
     550    my $result  = 0; 
     551    for my $field (@$order) { 
     552        my $path = undef; 
     553        ( my $f = $field ) =~ s/=.+//; 
     554        next 
     555          if ( 
     556            exists $node->{client}->{$service}->{ $f . ".process" } 
     557            and $node->{client}->{$service}->{ $f . ".process" } ne "yes" ); 
     558        next if ( exists $node->{client}->{$service}->{ $f . ".skipdraw" } ); 
     559        next 
     560          unless ( 
     561            !exists $node->{client}->{$service}->{ $f . ".graph" } 
     562            or $node->{client}->{$service}->{ $f . ".graph" } eq "yes" ); 
     563        if ($result < 
     564            length( $node->{client}->{$service}->{ $f . ".label" } || $f ) ) 
     565        { 
     566            $result = 
     567              length( $node->{client}->{$service}->{ $f . ".label" } || $f ); 
     568        } 
     569        if (exists $node->{client}->{$service}->{graph_total} 
     570            and length $node->{client}->{$service}->{graph_total} > $result ) 
     571        { 
     572            $result = length $node->{client}->{$service}->{graph_total}; 
     573        } 
     574    } ## end for my $field (@$order) 
     575    return $result; 
     576} ## end sub munin_get_max_label_length 
     577 
     578 
     579sub munin_get_field_order { 
     580    my $node    = shift; 
     581    my $config  = shift; 
     582    my $domain  = shift; 
     583    my $host    = shift; 
     584    my $service = shift; 
     585    my $result  = []; 
     586    if ( $node->{client}->{$service}->{graph_sources} ) { 
     587        foreach 
     588          my $gs ( split /\s+/, $node->{client}->{$service}->{'graph_sources'} ) 
     589        { 
     590            push( @$result, "-" . $gs ); 
     591        } 
     592    } 
     593    if ( $node->{client}->{$service}->{graph_order} ) { 
     594        push( 
     595            @$result, 
     596            split /\s+/, $node->{client}->{$service}->{'graph_order'} ); 
     597    } 
     598    for my $key ( keys %{ $node->{client}->{$service} } ) { 
     599        my ( $client, $type ) = ""; 
     600        ( $client, $type ) = split /\./, $key; 
     601        if ( defined $type and $type eq "label" ) { 
     602            push @$result, $client if !grep /^\Q$client\E(?:=|$)/, @$result; 
     603        } 
     604    } 
     605    return $result; 
     606} ## end sub munin_get_field_order 
     607 
     608 
     609sub munin_get_rrd_filename { 
     610    my $node    = shift; 
     611    my $config  = shift; 
     612    my $domain  = shift; 
     613    my $name    = shift; 
     614    my $service = shift; 
     615    my $field   = shift; 
     616    my $path    = shift; 
     617    my $result  = "unknown"; 
     618    if ( $node->{client}->{$service}->{ $field . ".filename" } ) { 
     619        $result = $node->{client}->{$service}->{ $field . ".filename" }; 
     620    } elsif ($path) { 
     621        if ( !defined( $node->{client}->{$service}->{ $field . ".label" } ) ) { 
     622            print "DEBUG: Setting label: $field\n" if $::DEBUG; 
     623            $node->{client}->{$service}->{ $field . ".label" } = $field; 
     624        } 
     625        if ( $path =~ /^\s*([^:;]+)[:;]([^:]+):([^:\.]+)[:\.]([^:\.]+)\s*$/ ) { 
     626            $result = munin_get_filename( $config, $1, $2, $3, $4 ); 
     627            print "\nDEBUG1: Expanding $path...\n" if $::DEBUG; 
     628            if ( !defined $node->{client}->{$service}->{ $field . "label" } ) { 
     629                for my $f (@copy_fields) { 
     630                    if (not exists $node->{client}->{$service}->{"$field.$f"} 
     631                        and exists $config->{'domain'}->{$1}->{'node'}->{$2} 
     632                        ->{'client'}->{$3}->{"$4.$f"} ) 
     633                    { 
     634                        $node->{client}->{$service}->{"$field.$f"} = 
     635                          $config->{'domain'}->{$1}->{'node'}->{$2}->{'client'} 
     636                          ->{$3}->{"$4.$f"}; 
     637                    } 
     638                } 
     639            } 
     640        } elsif ( $path =~ /^\s*([^:]+):([^:\.]+)[:\.]([^:\.]+)\s*$/ ) { 
     641            print "\nDEBUG2: Expanding $path...\n" if $::DEBUG; 
     642            $result = munin_get_filename( $config, $domain, $1, $2, $3 ); 
     643            for my $f (@copy_fields) { 
     644                if (not exists $node->{client}->{$service}->{"$field.$f"} 
     645                    and exists $config->{'domain'}->{$domain}->{'node'}->{$1} 
     646                    ->{'client'}->{$2}->{"$3.$f"} ) 
     647                { 
     648                    print "DEBUG: Copying $f...\n" if $::DEBUG; 
     649                    $node->{client}->{$service}->{"$field.$f"} = 
     650                      $config->{'domain'}->{$domain}->{'node'}->{$1}->{'client'} 
     651                      ->{$2}->{"$3.$f"}; 
     652                } 
     653            } 
     654        } elsif ( $path =~ /^\s*([^:\.]+)[:\.]([^:\.]+)\s*$/ ) { 
     655            print "\nDEBUG3: Expanding $path...\n" if $::DEBUG; 
     656            $result = munin_get_filename( $config, $domain, $name, $1, $2 ); 
     657            for my $f (@copy_fields) { 
     658                if (not exists $node->{client}->{$service}->{"$field.$f"} 
     659                    and exists $node->{client}->{$1}->{"$2.$f"} ) 
     660                { 
     661                    $node->{client}->{$service}->{"$field.$f"} = 
     662                      $node->{client}->{$1}->{"$2.$f"}; 
     663                } 
     664            } 
     665        } elsif ( $path =~ /^\s*([^:\.]+)\s*$/ ) { 
     666            print "\nDEBUG4: Expanding $path...\n" if $::DEBUG; 
     667            $result = 
     668              munin_get_filename( $config, $domain, $name, $service, $1 ); 
     669            for my $f (@copy_fields) { 
     670                if (not exists $node->{client}->{$service}->{"$field.$f"} 
     671                    and exists $node->{client}->{$service}->{"$1.$f"} ) 
     672                { 
     673                    $node->{client}->{$service}->{"$field.$f"} = 
     674                      $node->{client}->{$service}->{"$1.$f"}; 
     675                } 
     676            } 
     677        } 
     678    } else { 
     679        print "\nDEBUG5: Doing path...\n" if $::DEBUG; 
     680        $result = 
     681          munin_get_filename( $config, $domain, $name, $service, $field ); 
     682    } 
     683    return $result; 
     684} ## end sub munin_get_rrd_filename 
     685 
    3496861;