Changeset 1253 for people/janl

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

Indenting and playing with Eclipse

Files:

Legend:

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

    r1252 r1253  
    11package Munin; 
     2 
    23# 
    34# Copyright (C) 2003-2006 Jimmy Olsen, Audun Ytterdal, Nicolai Langfeldt 
     
    1819# 
    1920# $Id$ 
    20  
    2121use strict; 
    2222use Exporter; 
    23  
    2423use vars qw(@ISA @EXPORT @EXPORT_OK $VERSION $CONFDIR $DEBUG @legalfetch 
    25             @legalconfig @copy_fields); 
    26  
    27 @ISA = qw(main Exporter); 
    28  
     24  @legalconfig @copy_fields); 
     25@ISA    = qw(main Exporter); 
    2926@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 ); 
    38  
    39 @EXPORT_OK = ''; # qw($CONFDIR); 
    40  
     27  munin_removelock munin_runlock munin_getlock munin_delete 
     28  munin_overwrite munin_draw_field munin_get_bool 
     29  munin_get_bool_val munin_get munin_field_status 
     30  munin_service_status munin_node_status 
     31  munin_category_status munin_get_picture_filename 
     32  munin_get_filename munin_graph_column_headers 
     33  munin_get_max_label_length munin_get_field_order 
     34  munin_get_rrd_filename $CONFDIR $DEBUG ); 
     35@EXPORT_OK = '';    # qw($CONFDIR); 
    4136use RRDs; 
    4237use Fcntl qw(:DEFAULT :flock); 
    4338use IO::Handle; 
    4439use Symbol 'gensym'; 
    45  
    46 my $nsca = new IO::Handle; 
     40my $nsca   = new IO::Handle; 
    4741my $config = undef; 
    48 $DEBUG=0; 
    49  
    50 my $configfile='@@CONFDIR@@/munin.conf'; 
    51  
    52 @legalfetch = qw(.value); 
    53          
     42$DEBUG = 0; 
     43my $configfile = '@@CONFDIR@@/munin.conf'; 
     44@legalfetch  = qw(.value); 
    5445@legalconfig = qw( 
    55                 graph_order graph_title create_args graph_args 
    56                 graph_vlabel graph_vtitle graph_total graph_scale graph 
    57                 update host_name 
    58  
    59                 .label .cdef .draw .graph .max .min .negative 
    60                 .skipdraw .type .warning .critical .colour 
    61                 .graph_printf 
    62                 ); 
     46  graph_order graph_title create_args graph_args 
     47  graph_vlabel graph_vtitle graph_total graph_scale graph 
     48  update host_name 
     49  .label .cdef .draw .graph .max .min .negative 
     50  .skipdraw .type .warning .critical .colour 
     51  .graph_printf 
     52  ); 
    6353 
    6454# Fields to copy when "aliasing" a field 
    65 @copy_fields    = ("label", "draw", "type", "rrdfile", "fieldname", "info"); 
     55@copy_fields = ( "label", "draw", "type", "rrdfile", "fieldname", "info" ); 
    6656 
    6757# Make configuration settings available at runtime. 
    68 my $PREFIX               = '@@PREFIX@@'; 
    69 $ENV{'MUNIN_PREFIX'}     = $PREFIX; 
    70 $CONFDIR                 = '@@CONFDIR@@';   # /etc/munin,/etc/opt/munin or such 
     58my $PREFIX = '@@PREFIX@@'; 
     59$ENV{'MUNIN_PREFIX'} = $PREFIX; 
     60$CONFDIR = '@@CONFDIR@@';    # /etc/munin,/etc/opt/munin or such 
    7161print "CONFDIR: $CONFDIR!\n"; 
    72 $ENV{'MUNIN_CONFDIR'}    = $CONFDIR; 
    73 my $BINDIR               = '@@BINDIR@@'; 
    74 $ENV{'MUNIN_BINDIR'}     = $BINDIR; 
    75 my $SBINDIR              = '@@SBINDIR@@'; 
    76 $ENV{'MUNIN_SBINDIR'}    = $SBINDIR; 
    77 my $DOCDIR               = '@@DOCDIR@@'; 
    78 $ENV{'MUNIN_DOCDIR'}     = $DOCDIR; 
    79 my $LIBDIR               = '@@LIBDIR@@';    # LIBDIR/plugins contains plugin.sh 
    80 $ENV{'MUNIN_LIBDIR'}     = $LIBDIR; 
    81 my $HTMLDIR              = '@@HTMLDIR@@'; 
    82 $ENV{'MUNIN_HTMLDIR'}    = $HTMLDIR; 
    83 my $CGIDIR               = '@@CGIDIR@@'; 
    84 $ENV{'MUNIN_CGIDIR'}     = $CGIDIR; 
    85 my $DBDIR                = '@@DBDIR@@'; 
    86 $ENV{'MUNIN_DBDIR'}      = $DBDIR; 
    87 my $PLUGSTATE            = '@@PLUGSTATE@@'; # Put plugin state files here! 
    88 $ENV{'MUNIN_PLUGSTATE'} = $PLUGSTATE;      # Put plugin state files here! 
    89 my $MANDIR               = '@@MANDIR@@'; 
    90 $ENV{'MUNIN_MANDIR'}     = $MANDIR; 
    91 my $LOGDIR               = '@@LOGDIR@@'; 
    92 $ENV{'MUNIN_LOGDIR'}     = $LOGDIR; 
    93 my $STATEDIR             = '@@STATEDIR@@';  # This is for .pid files 
    94 $ENV{'MUNIN_STATEDIR'}   = $STATEDIR;       # This is for .pid files 
    95 my $USER                 = '@@USER@@';      # User munin runs as (mostly) 
    96 $ENV{'MUNIN_USER'}       = $USER;           # User munin runs as (mostly) 
    97 my $GROUP                = '@@GROUP@@';     # Group ditto 
    98 $ENV{'MUNIN_GROUP'}      = $GROUP;          # Group ditto 
    99 my $PLUGINUSER           = '@@PLUGINUSER@@';# Default user for plugin running 
    100 $ENV{'MUNIN_PLUGINUSER'} = $PLUGINUSER;     # Default user for plugin running 
     62$ENV{'MUNIN_CONFDIR'} = $CONFDIR; 
     63my $BINDIR = '@@BINDIR@@'; 
     64$ENV{'MUNIN_BINDIR'} = $BINDIR; 
     65my $SBINDIR = '@@SBINDIR@@'; 
     66$ENV{'MUNIN_SBINDIR'} = $SBINDIR; 
     67my $DOCDIR = '@@DOCDIR@@'; 
     68$ENV{'MUNIN_DOCDIR'} = $DOCDIR; 
     69my $LIBDIR = '@@LIBDIR@@';    # LIBDIR/plugins contains plugin.sh 
     70$ENV{'MUNIN_LIBDIR'} = $LIBDIR; 
     71my $HTMLDIR = '@@HTMLDIR@@'; 
     72$ENV{'MUNIN_HTMLDIR'} = $HTMLDIR; 
     73my $CGIDIR = '@@CGIDIR@@'; 
     74$ENV{'MUNIN_CGIDIR'} = $CGIDIR; 
     75my $DBDIR = '@@DBDIR@@'; 
     76$ENV{'MUNIN_DBDIR'} = $DBDIR; 
     77my $PLUGSTATE = '@@PLUGSTATE@@';    # Put plugin state files here! 
     78$ENV{'MUNIN_PLUGSTATE'} = $PLUGSTATE;    # Put plugin state files here! 
     79my $MANDIR = '@@MANDIR@@'; 
     80$ENV{'MUNIN_MANDIR'} = $MANDIR; 
     81my $LOGDIR = '@@LOGDIR@@'; 
     82$ENV{'MUNIN_LOGDIR'} = $LOGDIR; 
     83my $STATEDIR = '@@STATEDIR@@';           # This is for .pid files 
     84$ENV{'MUNIN_STATEDIR'} = $STATEDIR;      # This is for .pid files 
     85my $USER = '@@USER@@';                   # User munin runs as (mostly) 
     86$ENV{'MUNIN_USER'} = $USER;              # User munin runs as (mostly) 
     87my $GROUP = '@@GROUP@@';                 # Group ditto 
     88$ENV{'MUNIN_GROUP'} = $GROUP;            # Group ditto 
     89my $PLUGINUSER = '@@PLUGINUSER@@';       # Default user for plugin running 
     90$ENV{'MUNIN_PLUGINUSER'} = $PLUGINUSER;  # Default user for plugin running 
    10191$ENV{'MUNIN_VERSION'}    = $VERSION; 
    102 my $PERL                 = '@@PERL@@'; 
    103 $ENV{'MUNIN_PERL'}       = $PERL; 
    104 my $PERLLIB              = '@@PERLLIB@@'; 
    105 $ENV{'MUNIN_PERLLIB'}    = $PERLLIB; 
    106 my $GOODSH               = '@@GOODSH@@'; 
    107 $ENV{'MUNIN_GOODSH'}     = $GOODSH; 
    108 my $BASH                 = '@@BASH@@'; 
    109 $ENV{'MUNIN_BASH'}       = $BASH; 
    110 my $PYTHON               = '@@PYTHON@@'; 
    111 $ENV{'MUNIN_PYTHON'}     = $PYTHON; 
    112 my $OSTYPE               = '@@OSTYPE@@'; 
    113 $ENV{'MUNIN_OSTYPE'}     = $OSTYPE; 
    114 my $HOSTNAME             = '@@HOSTNAME@@'; 
    115 $ENV{'MUNIN_HOSTNAME'}   = $HOSTNAME; 
    116 my $MKTEMP               = '@@MKTEMP@@'; 
    117 $ENV{'MUNIN_MKTEMP'}     = $MKTEMP; 
     92my $PERL = '@@PERL@@'; 
     93$ENV{'MUNIN_PERL'} = $PERL; 
     94my $PERLLIB = '@@PERLLIB@@'; 
     95$ENV{'MUNIN_PERLLIB'} = $PERLLIB; 
     96my $GOODSH = '@@GOODSH@@'; 
     97$ENV{'MUNIN_GOODSH'} = $GOODSH; 
     98my $BASH = '@@BASH@@'; 
     99$ENV{'MUNIN_BASH'} = $BASH; 
     100my $PYTHON = '@@PYTHON@@'; 
     101$ENV{'MUNIN_PYTHON'} = $PYTHON; 
     102my $OSTYPE = '@@OSTYPE@@'; 
     103$ENV{'MUNIN_OSTYPE'} = $OSTYPE; 
     104my $HOSTNAME = '@@HOSTNAME@@'; 
     105$ENV{'MUNIN_HOSTNAME'} = $HOSTNAME; 
     106my $MKTEMP = '@@MKTEMP@@'; 
     107$ENV{'MUNIN_MKTEMP'} = $MKTEMP; 
    118108 
    119109sub munin_createlock { 
     110 
    120111    # Create lock file, fail and die if not possible. 
    121112    my ($lockname) = @_; 
    122     if (sysopen (LOCK,$lockname,O_WRONLY | O_CREAT | O_EXCL)) { 
    123        print "Creating lock : $lockname succeded\n" if $::DEBUG; 
    124        print LOCK $$; # we want the pid inside for later use 
    125        close LOCK; 
    126        return 1; 
     113    if ( sysopen( LOCK, $lockname, O_WRONLY | O_CREAT | O_EXCL ) ) { 
     114        print "Creating lock : $lockname succeded\n" if $::DEBUG; 
     115        print LOCK $$;    # we want the pid inside for later use 
     116        close LOCK; 
     117        return 1; 
    127118    } else { 
    128        die "Creating lock $lockname failed: $!\n"; 
     119        die "Creating lock $lockname failed: $!\n"; 
    129120    } 
    130121} 
    131122 
    132  
    133123sub munin_removelock { 
     124 
    134125    # Remove lock or die trying. 
    135126    my ($lockname) = @_; 
    136  
    137     unlink $lockname or 
    138       die "Error deleting lock $lockname: $!\n"; 
     127    unlink $lockname 
     128      or die "Error deleting lock $lockname: $!\n"; 
    139129} 
    140130 
    141131sub munin_runlock { 
     132 
     133    # Simple get lock: Get lock or die trying 
    142134    my ($lockname) = @_; 
    143     unless (&munin_getlock($lockname)) { 
    144        print "Lock already exists: $lockname. Dying.\n"; 
    145        exit 0
     135    unless ( &munin_getlock($lockname) ) { 
     136        print "Lock already exists: $lockname. Dying.\n"; 
     137        exit 1
    146138    } 
    147139    return 1; 
     
    149141 
    150142sub munin_getlock { 
     143 
     144    # Complicated get lock: Try getting it, if it's taken see if the 
     145    # invoking process is still alive. 
    151146    my ($lockname) = @_; 
    152     if (-f $lockname) { 
    153         # Is the lockpid alive? 
    154  
    155         # To check this is inteligent and so on.  It also makes for a 
    156         # nice locking racing-condition.  BUT, since munin-* runs from 
    157         # cron every 5 minutes this should not be a real threat.  This 
    158         # ream of code should complete in less than 5 minutes. 
    159  
    160         open LOCK,$lockname or  
    161           die "Could not open $lockname for reading: $!\n"; 
    162         my $pid = <LOCK>; 
    163         close(LOCK) or die "Could not close $lockname: $!\n"; 
    164         if (defined($pid) and $pid =~ /^\d+$/ and kill(0,$pid)) { 
    165             return 0; 
    166         } 
    167         &munin_removelock($lockname); 
    168         &munin_createlock($lockname); 
    169     } 
     147    if ( -f $lockname ) { 
     148 
     149        # Is the lockpid alive? 
     150        # To check this is inteligent and so on.  It also makes for a 
     151        # nice locking racing-condition.  BUT, since munin-* runs from 
     152        # cron every 5 minutes this should not be a real threat.  This 
     153        # ream of code should complete in less than 5 minutes. 
     154        open LOCK, $lockname 
     155          or die "Could not open $lockname for reading: $!\n"; 
     156        my $pid = <LOCK>; 
     157        close(LOCK) or die "Could not close $lockname: $!\n"; 
     158        if ( defined($pid) and $pid =~ /^\d+$/ and kill( 0, $pid ) ) { 
     159 
     160            # Process still alive.  Do not die, just return. 
     161            return 0; 
     162        } 
     163 
     164        # Process not alive, steal lock. munin_createlock will die if failed. 
     165        &munin_removelock($lockname); 
     166        &munin_createlock($lockname); 
     167    } ## end if ( -f $lockname ) 
    170168    return 1; 
    171 
    172  
     169} ## end sub munin_getlock 
    173170 
    174171sub munin_delete { 
    175172    # Delete a domain, and corresponding set of nodes from config tree 
    176  
    177     my ($config,$data) = @_; 
    178     for my $domain (keys %{$data->{domain}}) { 
    179         if (!$config->{domain}->{$domain}) { 
    180             ::logger("Removing domain: $domain"); 
    181             delete ($data->{domain}->{$domain}); 
    182             next; 
    183         } 
    184         for my $node (keys %{$data->{domain}->{$domain}->{node}}) { 
    185             unless ($config->{domain}->{$domain}->{node}->{$node}) { 
    186                 ::logger("Removing node from $domain: $node"); 
    187                 delete ($data->{domain}->{$domain}->{node}->{$node}); 
    188             } 
    189         } 
     173    my ( $config, $data ) = @_; 
     174    for my $domain ( keys %{ $data->{domain} } ) { 
     175        if ( !$config->{domain}->{$domain} ) { 
     176            ::logger("Removing domain: $domain"); 
     177            delete( $data->{domain}->{$domain} ); 
     178            next; 
     179        } 
     180        for my $node ( keys %{ $data->{domain}->{$domain}->{node} } ) { 
     181            unless ( $config->{domain}->{$domain}->{node}->{$node} ) { 
     182                ::logger("Removing node from $domain: $node"); 
     183                delete( $data->{domain}->{$domain}->{node}->{$node} ); 
     184            } 
     185        } 
    190186    } 
    191187    return ($data); 
    192188} 
    193189 
    194  
    195190sub munin_overwrite { 
    196     my ($configfile,$overwrite) = @_; 
    197     for my $key (keys %$overwrite) { 
    198        if (ref $overwrite->{$key}) { 
    199            &munin_overwrite($overwrite->{$key},$configfile->{$key}); 
    200        
    201        $configfile->{$key} = $overwrite->{$key}; 
     191    my ( $configfile, $overwrite ) = @_; 
     192    for my $key ( keys %$overwrite ) { 
     193        if ( ref $overwrite->{$key} ) { 
     194            &munin_overwrite( $overwrite->{$key}, $configfile->{$key} ); 
     195       
     196        $configfile->{$key} = $overwrite->{$key}; 
    202197    } 
    203198    return ($configfile); 
    204199} 
    205  
    206200 
    207201sub munin_get_picture_filename { 
     
    215209 
    216210    # Sanitise 
    217     $dir =~ s/[^\w_\/"'\[\]\(\)+=-]\./_/g; 
    218     $domain =~ s/[^\w_\/"'\[\]\(\)+=\.-]/_/g; 
    219     $name =~ s/[^\w_\/"'\[\]\(\)+=\.-]/_/g; 
     211    $dir     =~ s/[^\w_\/"'\[\]\(\)+=-]\./_/g; 
     212    $domain =~ s/[^\w_\/"'\[\]\(\)+=\.-]/_/g; 
     213    $name    =~ s/[^\w_\/"'\[\]\(\)+=\.-]/_/g; 
    220214    $service =~ s/[^\w_\/"'\[\]\(\)+=-]/_/g; 
    221     $scale =~ s/[^\w_\/"'\[\]\(\)+=-]/_/g; 
    222  
    223     if (defined $sum and $sum) { 
    224             return "$dir/$domain/$name-$service-$scale-sum.png"; 
     215    $scale   =~ s/[^\w_\/"'\[\]\(\)+=-]/_/g; 
     216    if ( defined $sum and $sum ) { 
     217        return "$dir/$domain/$name-$service-$scale-sum.png"; 
    225218    } else { 
    226             return "$dir/$domain/$name-$service-$scale.png"; 
    227     } 
     219        return "$dir/$domain/$name-$service-$scale.png"; 
     220    } 
     221} ## end sub munin_get_picture_filename 
     222 
     223sub munin_get_filename { 
     224    my ( $config, $domain, $node, $service, $field ) = @_; 
     225    return ( 
     226        $config->{'dbdir'} . "/$domain/$node-$service-$field-" 
     227          . lc substr( 
     228            ( 
     229                $config->{domain}->{$domain}->{node}->{$node}->{client} 
     230                  ->{$service}->{ $field . ".type" } || "GAUGE" 
     231            ), 
     232            0, 1 
     233          ) 
     234          . ".rrd" 
     235    ); 
    228236} 
    229237 
    230 sub munin_get_filename { 
    231         my ($config,$domain,$node,$service,$field) = @_; 
    232  
    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  
    238238sub munin_get_bool { 
    239     my $conf     = shift; 
    240     my $field    = shift; 
    241     my $default  = shift; 
    242     my $domain   = shift; 
    243     my $node     = shift; 
    244     my $service  = shift; 
    245     my $plot     = shift; 
    246  
     239    my $conf    = shift; 
     240    my $field   = shift; 
     241    my $default = shift; 
     242    my $domain  = shift; 
     243    my $node    = shift; 
     244    my $service = shift; 
     245    my $plot    = shift; 
    247246    return undef unless defined $field; 
    248  
    249     my $ans = &munin_get ($conf, $field, $default, $domain, $node, $service, $plot); 
     247    my $ans = 
     248      &munin_get( $conf, $field, $default, $domain, $node, $service, $plot ); 
    250249    return undef if not defined $ans; 
    251250 
    252     if ($ans =~ /^yes$/i or 
    253         $ans =~ /^true$/i or 
    254         $ans =~ /^on$/i or 
    255         $ans =~ /^enable$/i or 
    256         $ans =~ /^enabled$/i 
    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; 
     251    if ($ans    =~ /^yes$/i 
     252        or $ans =~ /^true$/i 
     253        or $ans =~ /^on$/i 
     254        or $ans =~ /^enable$/i 
     255        or $ans =~ /^enabled$/i ) 
     256    { 
     257        return 1; 
     258    } elsif ( 
     259        $ans    =~ /^no$/i 
     260        or $ans =~ /^false$/i 
     261        or $ans =~ /^off$/i 
     262        or $ans =~ /^disable$/i 
     263        or $ans =~ /^disabled$/i ) 
     264    { 
     265        return 0; 
     266    } elsif ( $ans !~ /\D/ ) { 
     267        return $ans; 
    267268    } else { 
    268        return undef; 
    269     } 
    270 } 
    271  
    272 sub munin_get_bool_val 
    273 
    274     my $field    = shift; 
    275     my $default  = shift; 
    276  
    277     if (!defined $field) { 
    278        if (!defined $default)
    279            return 0
    280         } else { 
    281             return $default; 
    282         } 
    283     } 
    284  
    285     if ($field =~ /^yes$/i or 
    286         $field =~ /^true$/i or 
    287         $field =~ /^on$/i or 
    288         $field =~ /^enable$/i or 
    289         $field =~ /^enabled$/i) { 
    290         return 1; 
    291     } elsif ($field =~ /^no$/i or 
    292         $field =~ /^false$/i or 
    293         $field =~ /^off$/i or 
    294         $field =~ /^disable$/i or 
    295         $field =~ /^disabled$/i)
    296        return 0; 
    297     } elsif ($field !~ /\D/) { 
    298        return $field; 
     269        return undef; 
     270    } 
     271} ## end sub munin_get_bool 
     272 
     273sub munin_get_bool_val { 
     274    my $field   = shift; 
     275    my $default = shift; 
     276    if ( !defined $field ) { 
     277        if ( !defined $default ) { 
     278            return 0; 
     279        } else
     280            return $default
     281        } 
     282    } 
     283    if ($field    =~ /^yes$/i 
     284        or $field =~ /^true$/i 
     285        or $field =~ /^on$/i 
     286        or $field =~ /^enable$/i 
     287        or $field =~ /^enabled$/i ) 
     288    { 
     289        return 1; 
     290    } elsif ( 
     291        $field    =~ /^no$/i 
     292        or $field =~ /^false$/i 
     293        or $field =~ /^off$/i 
     294        or $field =~ /^disable$/i 
     295        or $field =~ /^disabled$/i ) 
     296   
     297        return 0; 
     298    } elsif ( $field !~ /\D/ ) { 
     299        return $field; 
    299300    } else { 
    300        return undef; 
    301     } 
    302 } 
     301        return undef; 
     302    } 
     303} ## end sub munin_get_bool_val 
    303304 
    304305sub munin_get { 
     
    307308    # "recurse" upwards.  This allows defaulting at shalow levels and 
    308309    # specific overrides at deeper levels. 
    309  
    310     my $conf     = shift; 
    311     my $field    = shift; 
    312     my $default  = shift; 
    313     my $domain   = shift; 
    314     my $node     = shift; 
    315     my $service  = shift; 
    316     my $plot     = shift; 
    317  
    318     if (defined $field) { 
    319  
    320         return $conf->{domain}->{$domain}->{node}->{$node}->{client}->{$service}->{"$plot.$field"} 
    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}); 
    337          
    338         return $conf->{domain}->{$domain}->{$field} 
    339           if (defined $domain and 
    340               defined $conf->{domain}->{$domain}->{$field}); 
    341  
    342         return $conf->{$field} 
    343           if (defined $conf->{$field}); 
    344  
    345         return $default; 
    346  
     310    my $conf    = shift; 
     311    my $field   = shift; 
     312    my $default = shift; 
     313    my $domain  = shift; 
     314    my $node    = shift; 
     315    my $service = shift; 
     316    my $plot    = shift; 
     317    if ( defined $field ) { 
     318        return $conf->{domain}->{$domain}->{node}->{$node}->{client}->{$service} 
     319          ->{"$plot.$field"} 
     320          if ( 
     321            defined $domain 
     322            and defined $node 
     323            and defined $service 
     324            and defined $plot 
     325            and defined $conf->{domain}->{$domain}->{node}->{$node}->{client} 
     326            ->{$service}->{"$plot.$field"} ); 
     327        return $conf->{domain}->{$domain}->{node}->{$node}->{client}->{$service} 
     328          ->{$field} 
     329          if ( 
     330            defined $domain 
     331            and defined $node 
     332            and defined $service 
     333            and defined $conf->{domain}->{$domain}->{node}->{$node}->{client} 
     334            ->{$service}->{$field} ); 
     335        return $conf->{domain}->{$domain}->{node}->{$node}->{$field} 
     336          if ( 
     337            defined $domain 
     338            and defined $node 
     339            and defined $conf->{domain}->{$domain}->{node}->{$node}->{$field} ); 
     340        return $conf->{domain}->{$domain}->{$field} 
     341          if ( 
     342            defined $domain 
     343            and defined $conf->{domain}->{$domain}->{$field} ); 
     344        return $conf->{$field} 
     345          if ( defined $conf->{$field} ); 
     346        return $default; 
    347347    } else { 
    348  
    349         return $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  
    355         return $conf->{domain}->{$domain}->{node}->{$node} 
    356           if (defined $domain and 
    357               defined $node and 
    358               defined $conf->{domain}->{$domain}->{node}->{$node}); 
    359  
    360         return $conf->{domain}->{$domain} 
    361           if (defined $domain and 
    362               defined $conf->{domain}->{$domain}); 
    363  
    364         return $conf 
    365           if (defined $conf); 
    366  
    367         return $default; 
    368     } 
    369 
    370  
     348        return $conf->{domain}->{$domain}->{node}->{$node}->{client}->{$service} 
     349          if ( 
     350            defined $domain 
     351            and defined $node 
     352            and defined $service 
     353            and defined $conf->{domain}->{$domain}->{node}->{$node}->{client} 
     354            ->{$service} ); 
     355        return $conf->{domain}->{$domain}->{node}->{$node} 
     356          if ( 
     357            defined $domain 
     358            and defined $node 
     359            and defined $conf->{domain}->{$domain}->{node}->{$node} ); 
     360        return $conf->{domain}->{$domain} 
     361          if ( 
     362            defined $domain 
     363            and defined $conf->{domain}->{$domain} ); 
     364        return $conf 
     365          if ( defined $conf ); 
     366        return $default; 
     367    } ## end else [ if ( defined $field ) 
     368} ## end sub munin_get 
    371369 
    372370sub munin_node_status { 
    373     my ($config, $limits, $domain, $node, $check_draw) = @_; 
     371    my ( $config, $limits, $domain, $node, $check_draw ) = @_; 
    374372    my $state = "ok"; 
    375  
    376373    return undef unless defined $config->{domain}->{$domain}->{node}->{$node}; 
    377374    my $snode = $config->{domain}->{$domain}->{node}->{$node}; 
    378  
    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") { 
    385                 $state = $fres; 
    386                 last; 
    387             } elsif ($fres eq "warning") { 
    388                 $state = $fres; 
    389             } 
    390         } 
    391     } 
    392  
     375    foreach my $service ( keys %{$snode} ) { 
     376        my $fres = 
     377          &munin_service_status( 
     378            $config, $limits, $domain, $node, $service, 
     379            $check_draw ); 
     380        if ( defined $fres ) { 
     381            if ( $fres eq "critical" ) { 
     382                $state = $fres; 
     383                last; 
     384            } elsif ( $fres eq "warning" ) { 
     385                $state = $fres; 
     386            } 
     387        } 
     388    } 
    393389    return $state; 
    394 
    395  
     390} ## end sub munin_node_status 
    396391 
    397392sub munin_category_status { 
    398     my ($config, $limits, $domain, $node, $category, $check_draw) = @_; 
     393    my ( $config, $limits, $domain, $node, $category, $check_draw ) = @_; 
    399394    my $state = "ok"; 
    400  
    401395    return undef unless defined $config->{domain}->{$domain}->{node}->{$node}; 
    402396    my $snode = $config->{domain}->{$domain}->{node}->{$node}; 
    403  
    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") { 
    418                 $state = $fres; 
    419                last
    420             } elsif ($fres eq "warning") { 
    421                 $state = $fres; 
    422             } 
    423        
    424    
    425  
     397    foreach my $service ( keys %{ $snode->{client} } ) { 
     398        next 
     399          if ( 
     400            ( not defined $snode->{client}->{$service}->{graph_category} ) 
     401            and $category ne 'other' ); 
     402        next 
     403          if ( 
     404            ( defined $snode->{client}->{$service}->{graph_category} ) 
     405            and ( $snode->{client}->{$service}->{graph_category} ne $category ) 
     406          ); 
     407        my $fres = 
     408          &munin_service_status( 
     409            $config, $limits, $domain, $node, $service, 
     410            $check_draw ); 
     411        if ( defined $fres ) { 
     412            if ( $fres eq "critical" ) { 
     413                $state = $fres
     414                last; 
     415            } elsif ( $fres eq "warning" ) { 
     416                $state = $fres; 
     417           
     418       
     419    } ## end foreach my $service ( keys ... 
    426420    return $state; 
    427 
    428  
     421} ## end sub munin_category_status 
    429422 
    430423sub munin_service_status { 
    431     my ($config, $limits, $domain, $node, $service, $check_draw) = @_; 
     424    my ( $config, $limits, $domain, $node, $service, $check_draw ) = @_; 
    432425    my $state = "ok"; 
    433  
    434426    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}}) { 
    438         next unless $key =~ /^([^\.]+)\.label$/; 
    439         my $field = $1; 
    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") { 
    445                 $state = $fres; 
    446                 last; 
    447             } elsif ($fres eq "warning") { 
    448                 $state = $fres; 
    449             } 
    450         } 
    451     } 
     427      unless defined $config->{domain}->{$domain}->{node}->{$node}->{client} 
     428      ->{$service}; 
     429    foreach my $key ( 
     430        keys 
     431        %{ $config->{domain}->{$domain}->{node}->{$node}->{client}->{$service} } 
     432      ) 
     433    { 
     434        next unless $key =~ /^([^\.]+)\.label$/; 
     435        my $field = $1; 
     436        my $fres  = 
     437          &munin_field_status( 
     438            $config, $limits, $domain, $node, $service, 
     439            $field, $check_draw ); 
     440        if ( defined $fres ) { 
     441            if ( $fres eq "critical" ) { 
     442                $state = $fres; 
     443                last; 
     444            } elsif ( $fres eq "warning" ) { 
     445                $state = $fres; 
     446            } 
     447        } 
     448    } ## end foreach my $key ( keys %{ $config... 
    452449    return $state; 
    453 
    454  
     450} ## end sub munin_service_status 
    455451 
    456452sub munin_field_status { 
     453 
    457454    # Something to do with warning and critical levels. 
    458  
    459455    # Appears to not set warning/critical state if "nagios" is turned 
    460456    # off.  Isn't that a bit odd? 
    461  
    462     my ($config, $limits, $domain, $node, $service, $field, $check_draw) = @_; 
     457    my ( $config, $limits, $domain, $node, $service, $field, $check_draw ) = @_; 
    463458    my $state = undef; 
    464459 
    465460    # Return undef if nagios is turned off, or the field doesn't have any limits 
    466     unless ((defined $config->{domain}->{$domain}->{node}->{$node}->{client}->{$service}->{"$field.warning"}) or 
    467         (defined $config->{domain}->{$domain}->{node}->{$node}->{client}->{$service}->{"$field.critical"})) { 
    468         return undef; 
    469     } 
    470  
    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))) 
    474     { 
    475         return "critical"; 
    476     } 
    477     elsif (defined $limits->{domain}->{$domain}->{node}->{$node}->{client}->{$service}->{"$field.warning"} and (!defined $check_draw or !$check_draw or  
    478                 &munin_draw_field ($config->{domain}->{$domain}->{node}->{$node}, $service, $field))) 
    479     { 
    480         return "warning"; 
    481     } 
    482     else 
    483     { 
    484         return "ok"; 
    485     } 
    486 
    487  
    488 sub munin_graph_column_headers 
    489 
    490     my ($config, $domain, $node, $serv) = @_; 
    491     my $ret = 0; 
     461    unless ( 
     462        ( 
     463            defined $config->{domain}->{$domain}->{node}->{$node}->{client} 
     464            ->{$service}->{"$field.warning"} 
     465        ) 
     466        or ( 
     467            defined $config->{domain}->{$domain}->{node}->{$node}->{client} 
     468            ->{$service}->{"$field.critical"} ) 
     469      ) 
     470    { 
     471        return undef; 
     472    } 
     473    if ( 
     474        defined $limits->{domain}->{$domain}->{node}->{$node}->{client} 
     475        ->{$service}->{"$field.critical"} 
     476        and ( 
     477            !defined $check_draw 
     478            or !$check_draw 
     479            or &munin_draw_field( 
     480                $config->{domain}->{$domain}->{node}->{$node}, 
     481                $service, $field 
     482            ) 
     483        ) 
     484       ) 
     485    { 
     486        return "critical"; 
     487    } 
     488    elsif ( 
     489        defined $limits->{domain}->{$domain}->{node}->{$node}->{client} 
     490        ->{$service}->{"$field.warning"} 
     491        and ( 
     492            !defined $check_draw 
     493            or !$check_draw 
     494            or &munin_draw_field( 
     495                $config->{domain}->{$domain}->{node}->{$node}, 
     496                $service, $field 
     497            ) 
     498        ) 
     499      ) 
     500    { 
     501        return "warning"; 
     502    } else { 
     503        return "ok"; 
     504    } 
     505} ## end sub munin_field_status 
     506 
     507sub munin_graph_column_headers { 
     508    my ( $config, $domain, $node, $serv ) = @_; 
     509    my $ret    = 0; 
    492510    my @fields = (); 
    493  
    494     foreach my $field (keys %{$config->{domain}->{$domain}->{node}->{$node}->{client}->{$serv}}) 
    495     { 
    496         if ($field =~ /^([^\.]+)\.negative$/ and munin_draw_field ($config->{domain}->{$domain}->{node}->{$node}, $serv, $1)) 
    497         { 
    498             return 1; 
    499         } 
    500         elsif ($field =~ /^([^\.]+)\.label$/ and munin_draw_field ($config->{domain}->{$domain}->{node}->{$node}, $serv, $1)) 
    501         { 
    502             push @fields, $1; 
    503         } 
    504     } 
    505  
    506     return 1 if (munin_get_max_label_length ($config->{'domain'}->{$domain}->{'node'}->{$node}, $config, $domain, $node, $serv, \@fields) > 20); 
    507  
     511    foreach my $field ( 
     512        keys 
     513        %{ $config->{domain}->{$domain}->{node}->{$node}->{client}->{$serv} } ) 
     514    { 
     515        if ( 
     516            $field =~ /^([^\.]+)\.negative$/ 
     517            and munin_draw_field( 
     518                $config->{domain}->{$domain}->{node}->{$node}, 
     519                $serv, $1 
     520            ) 
     521           ) 
     522        { 
     523            return 1; 
     524        } 
     525        elsif ( 
     526            $field =~ /^([^\.]+)\.label$/ 
     527            and munin_draw_field( 
     528                $config->{domain}->{$domain}->{node}->{$node}, 
     529                $serv, $1 
     530            ) 
     531          ) 
     532        { 
     533            push @fields, $1; 
     534        } 
     535    } ## end foreach my $field ( keys %{... 
     536    return 1 
     537      if ( 
     538        munin_get_max_label_length( 
     539            $config->{'domain'}->{$domain}->{'node'}->{$node}, 
     540            $config, $domain, $node, $serv, \@fields 
     541        ) > 20 
     542      ); 
    508543    return $ret; 
    509 
    510  
    511 sub munin_get_max_label_length 
    512 
     544} ## end sub munin_graph_column_headers 
     545 
     546sub munin_get_max_label_length { 
    513547    my $node    = shift; 
    514548    my $config  = shift; 
     
    518552    my $order   = shift; 
    519553    my $result  = 0; 
    520  
    521554    for my $field (@$order) { 
    522         my $path = undef; 
    523         (my $f = $field) =~ s/=.+//; 
    524         next if (exists $node->{client}->{$service}->{$f.".process"} and 
    525                  $node->{client}->{$service}->{$f.".process"} ne "yes"); 
    526         next if (exists $node->{client}->{$service}->{$f.".skipdraw"}); 
    527         next unless (!exists $node->{client}->{$service}->{$f.".graph"} or 
    528                         $node->{client}->{$service}->{$f.".graph"} eq "yes"); 
    529         if ($result < length ($node->{client}->{$service}->{$f.".label"} || $f)) { 
    530             $result = length ($node->{client}->{$service}->{$f.".label"} || $f); 
    531         } 
    532         if (exists $node->{client}->{$service}->{graph_total} and  
    533                 length $node->{client}->{$service}->{graph_total} > $result) 
    534         { 
    535             $result = length $node->{client}->{$service}->{graph_total}; 
    536         } 
    537     } 
     555        my $path = undef; 
     556        ( my $f = $field ) =~ s/=.+//; 
     557        next 
     558          if ( 
     559            exists $node->{client}->{$service}->{ $f . ".process" } 
     560            and $node->{client}->{$service}->{ $f . ".process" } ne "yes" ); 
     561        next if ( exists $node->{client}->{$service}->{ $f . ".skipdraw" } ); 
     562        next 
     563          unless ( 
     564            !exists $node->{client}->{$service}->{ $f . ".graph" } 
     565            or $node->{client}->{$service}->{ $f . ".graph" } eq "yes" ); 
     566        if ($result < 
     567            length( $node->{client}->{$service}->{ $f . ".label" } || $f ) ) 
     568        { 
     569            $result = 
     570              length( $node->{client}->{$service}->{ $f . ".label" } || $f ); 
     571        } 
     572        if (exists $node->{client}->{$service}->{graph_total} 
     573            and length $node->{client}->{$service}->{graph_total} > $result ) 
     574        { 
     575            $result = length $node->{client}->{$service}->{graph_total}; 
     576        } 
     577    } ## end for my $field (@$order) 
    538578    return $result; 
    539 
    540  
    541 sub munin_get_field_order 
    542 
     579} ## end sub munin_get_max_label_length 
     580 
     581sub munin_get_field_order { 
    543582    my $node    = shift; 
    544583    my $config  = shift; 
     
    547586    my $service = shift; 
    548587    my $result  = []; 
    549  
    550     if ($node->{client}->{$service}->{graph_sources})  
    551     { 
    552         foreach my $gs (split /\s+/, $node->{client}->{$service}->{'graph_sources'}) 
    553         { 
    554             push (@$result, "-".$gs); 
    555         } 
    556     }  
    557     if ($node->{client}->{$service}->{graph_order})  
    558     { 
    559         push (@$result, split /\s+/, $node->{client}->{$service}->{'graph_order'}); 
    560     }  
    561  
    562     for my $key (keys %{$node->{client}->{$service}})  
    563     { 
    564         my ($client,$type)=""; 
    565         ($client,$type) = split /\./,$key; 
    566         if (defined $type and $type eq "label")  
    567         { 
    568             push @$result,$client if !grep /^\Q$client\E(?:=|$)/, @$result;; 
    569         }  
    570     } 
    571      
     588    if ( $node->{client}->{$service}->{graph_sources} ) { 
     589        foreach 
     590          my $gs ( split /\s+/, $node->{client}->{$service}->{'graph_sources'} ) 
     591        { 
     592            push( @$result, "-" . $gs ); 
     593        } 
     594    } 
     595    if ( $node->{client}->{$service}->{graph_order} ) { 
     596        push( 
     597            @$result, 
     598            split /\s+/, $node->{client}->{$service}->{'graph_order'} ); 
     599    } 
     600    for my $key ( keys %{ $node->{client}->{$service} } ) { 
     601        my ( $client, $type ) = ""; 
     602        ( $client, $type ) = split /\./, $key; 
     603        if ( defined $type and $type eq "label" ) { 
     604            push @$result, $client if !grep /^\Q$client\E(?:=|$)/, @$result; 
     605        } 
     606    } 
    572607    return $result; 
    573 } 
     608} ## end sub munin_get_field_order 
    574609 
    575610sub munin_get_rrd_filename { 
     
    582617    my $path    = shift; 
    583618    my $result  = "unknown"; 
    584  
    585     if ($node->{client}->{$service}->{$field.".filename"}) 
    586     { 
    587         $result = $node->{client}->{$service}->{$field.".filename"}; 
    588     } 
    589     elsif ($path) 
    590     { 
    591         if (!defined ($node->{client}->{$service}->{$field.".label"})) 
    592         { 
    593             print "DEBUG: Setting label: $field\n" if $DEBUG; 
    594             $node->{client}->{$service}->{$field.".label"} = $field; 
    595         } 
    596  
    597         if ($path =~ /^\s*([^:;]+)[:;]([^:]+):([^:\.]+)[:\.]([^:\.]+)\s*$/) 
    598         { 
    599             $result = munin_get_filename ($config, $1, $2, $3, $4); 
    600             print "\nDEBUG1: Expanding $path...\n" if $DEBUG; 
    601             if (! defined $node->{client}->{$service}->{$field."label"}) 
    602             { 
    603                 for my $f (@copy_fields) 
    604                 { 
    605                     if (not exists $node->{client}->{$service}->{"$field.$f"} and 
    606                             exists $config->{'domain'}->{$1}->{'node'}->{$2}->{'client'}->{$3}->{"$4.$f"}) 
    607                     { 
    608                         $node->{client}->{$service}->{"$field.$f"} = $config->{'domain'}->{$1}->{'node'}->{$2}->{'client'}->{$3}->{"$4.$f"}; 
    609                     } 
    610                 } 
    611             } 
    612         } 
    613         elsif ($path =~ /^\s*([^:]+):([^:\.]+)[:\.]([^:\.]+)\s*$/) 
    614         { 
    615             print "\nDEBUG2: Expanding $path...\n" if $DEBUG; 
    616             $result = munin_get_filename ($config, $domain, $1, $2, $3); 
    617             for my $f (@copy_fields) 
    618             { 
    619                 if (not exists $node->{client}->{$service}->{"$field.$f"} and 
    620                         exists $config->{'domain'}->{$domain}->{'node'}->{$1}->{'client'}->{$2}->{"$3.$f"}) 
    621                 { 
    622                     print "DEBUG: Copying $f...\n" if $DEBUG; 
    623                     $node->{client}->{$service}->{"$field.$f"} = $config->{'domain'}->{$domain}->{'node'}->{$1}->{'client'}->{$2}->{"$3.$f"}; 
    624                 } 
    625             } 
    626         } 
    627         elsif ($path =~ /^\s*([^:\.]+)[:\.]([^:\.]+)\s*$/) 
    628         { 
    629             print "\nDEBUG3: Expanding $path...\n" if $DEBUG; 
    630             $result = munin_get_filename ($config, $domain, $name, $1, $2); 
    631             for my $f (@copy_fields) 
    632             { 
    633                 if (not exists $node->{client}->{$service}->{"$field.$f"} and 
    634                         exists $node->{client}->{$1}->{"$2.$f"}) 
    635                 { 
    636                     $node->{client}->{$service}->{"$field.$f"} = $node->{client}->{$1}->{"$2.$f"}; 
    637                 } 
    638             } 
    639         } 
    640         elsif ($path =~ /^\s*([^:\.]+)\s*$/) 
    641         { 
    642             print "\nDEBUG4: Expanding $path...\n" if $DEBUG; 
    643             $result = munin_get_filename ($config, $domain, $name, $service, $1); 
    644             for my $f (@copy_fields) 
    645             { 
    646                 if (not exists $node->{client}->{$service}->{"$field.$f"} and 
    647                         exists $node->{client}->{$service}->{"$1.$f"}) 
    648                 { 
    649                     $node->{client}->{$service}->{"$field.$f"} = $node->{client}->{$service}->{"$1.$f"}; 
    650                 } 
    651             } 
    652         } 
    653     } 
    654     else 
    655     { 
    656         print "\nDEBUG5: Doing path...\n" if $DEBUG; 
    657         $result = munin_get_filename($config, $domain,$name,$service,$field); 
     619    if ( $node->{client}->{$service}->{ $field . ".filename" } ) { 
     620        $result = $node->{client}->{$service}->{ $field . ".filename" }; 
     621    } elsif ($path) { 
     622        if ( !defined( $node->{client}->{$service}->{ $field . ".label" } ) ) { 
     623            print "DEBUG: Setting label: $field\n" if $DEBUG; 
     624            $node->{client}->{$service}->{ $field . ".label" } = $field; 
     625        } 
     626        if ( $path =~ /^\s*([^:;]+)[:;]([^:]+):([^:\.]+)[:\.]([^:\.]+)\s*$/ ) { 
     627            $result = munin_get_filename( $config, $1, $2, $3, $4 ); 
     628            print "\nDEBUG1: Expanding $path...\n" if $DEBUG; 
     629            if ( !defined $node->{client}->{$service}->{ $field . "label" } ) { 
     630                for my $f (@copy_fields) { 
     631                    if (not exists $node->{client}->{$service}->{"$field.$f"} 
     632                        and exists $config->{'domain'}->{$1}->{'node'}->{$2} 
     633                        ->{'client'}->{$3}->{"$4.$f"} ) 
     634                    { 
     635                        $node->{client}->{$service}->{"$field.$f"} = 
     636                          $config->{'domain'}->{$1}->{'node'}->{$2}->{'client'} 
     637                          ->{$3}->{"$4.$f"}; 
     638                    } 
     639                } 
     640            } 
     641        } elsif ( $path =~ /^\s*([^:]+):([^:\.]+)[:\.]([^:\.]+)\s*$/ ) { 
     642            print "\nDEBUG2: Expanding $path...\n" if $DEBUG; 
     643            $result = munin_get_filename( $config, $domain, $1, $2, $3 ); 
     644            for my $f (@copy_fields) { 
     645                if (not exists $node->{client}->{$service}->{"$field.$f"} 
     646                    and exists $config->{'domain'}->{$domain}->{'node'}->{$1} 
     647                    ->{'client'}->{$2}->{"$3.$f"} ) 
     648                { 
     649                    print "DEBUG: Copying $f...\n" if $DEBUG; 
     650                    $node->{client}->{$service}->{"$field.$f"} = 
     651                      $config->{'domain'}->{$domain}->{'node'}->{$1}->{'client'} 
     652                      ->{$2}->{"$3.$f"}; 
     653                } 
     654            } 
     655        } elsif ( $path =~ /^\s*([^:\.]+)[:\.]([^:\.]+)\s*$/ ) { 
     656            print "\nDEBUG3: Expanding $path...\n" if $DEBUG; 
     657            $result = munin_get_filename( $config, $domain, $name, $1, $2 ); 
     658            for my $f (@copy_fields) { 
     659                if (not exists $node->{client}->{$service}->{"$field.$f"} 
     660                    and exists $node->{client}->{$1}->{"$2.$f"} ) 
     661                { 
     662                    $node->{client}->{$service}->{"$field.$f"} = 
     663                      $node->{client}->{$1}->{"$2.$f"}; 
     664                } 
     665            } 
     666        } elsif ( $path =~ /^\s*([^:\.]+)\s*$/ ) { 
     667            print "\nDEBUG4: Expanding $path...\n" if $DEBUG; 
     668            $result = 
     669              munin_get_filename( $config, $domain, $name, $service, $1 ); 
     670            for my $f (@copy_fields) { 
     671                if (not exists $node->{client}->{$service}->{"$field.$f"} 
     672                    and exists $node->{client}->{$service}->{"$1.$f"} ) 
     673                { 
     674                    $node->{client}->{$service}->{"$field.$f"} = 
     675                      $node->{client}->{$service}->{"$1.$f"}; 
     676                } 
     677            } 
     678        } 
     679    } else { 
     680        print "\nDEBUG5: Doing path...\n" if $DEBUG; 
     681        $result = 
     682          munin_get_filename( $config, $domain, $name, $service, $field ); 
    658683    } 
    659684    return $result; 
    660 
    661  
    662  
     685} ## end sub munin_get_rrd_filename 
    6636861; 
    664687