File Coverage

blib/lib/Lemonldap/Cluster/Status.pm

Criterion	Covered	Total	%
statement	9	126	7.1
branch	0	28	0.0
condition	0	3	0.0
subroutine	3	7	42.8
pod	1	4	25.0
total	13	168	7.7

package Lemonldap::Cluster::Status;

use strict;
use warnings;
use LWP::UserAgent;

require Exporter;

our @ISA = qw(Exporter);

# Items to export into callers namespace by default. Note: do not export
# names by default without a very good reason. Use EXPORT_OK instead.
# Do not simply export all your public functions/methods/constants.

# This allows declaration	use Lemonldap::Cluster::Status ':all';
# If you do not need this, moving things directly into @EXPORT or @EXPORT_OK
# will save memory.
our %EXPORT_TAGS = ( 'all' => [ qw(

) ] );

our @EXPORT_OK = ( @{ $EXPORT_TAGS{'all'} } );

our @EXPORT = qw(

);

our $VERSION = '0.02';


# Preloaded methods go here.
sub new {
    my $that =shift;
    my $class = ref($that)|| $that ;

     my $self ={};
	bless ($self,$class);
  %$self= @_;
#### init nb node ####
	my $cp;
	my @nodes;
	foreach (keys %$self ) {
	    next if /^ADMIN/i ;
		$cp++ ;
          push @nodes,$_;

    }

	$self->{NODES} = $cp;
	$self->{anode} =\@nodes;
#####
#### init time  ###
$self->{TIME} = localtime();

#####
    $self->{VERSION}= $VERSION;
#### load nodes infos
####
my %result;
my @NOEUD = @{$self->{anode} };
foreach (@NOEUD) {
	##
my $retour = collect($self->{$_});
$result{$_} = $retour;


}
$self->{RESULT} = \%result;


return $self;

}
sub PrintHtml {
    my $self =shift;
###  formate unit ####
    my $t= $self->{TMB} ;
my  $unite='MB' ;
  if ($t  > 1023 ) {
	$unite = 'GB';
    $t= $t / 1024 ;
 }
$t = sprintf("%.2f",$t);
    my $tr =$self->{TREQUEST};
    my $ta = $self->{ACCESSES} ;
#    $ta=~ s/(\d{3})$/\.$1/;
# $ta=~ s/^(\d+)(\d{3})/$1\.$2/;

my $message= <




Cluster Apache Status


Cluster Apache Status for $self->{ADMIN} Group
Lemonldap::Cluster::Status version: $self->{VERSION}

Current Time: $self->{TIME}
Number of Nodes: $self->{TNODES} : Status : $self->{STATUS}
Total accesses: $ta - Total Traffic: $t $unite
CPU Usage: min: $self->{MIN}% max: $self->{MAX}% ave : $self->{MOY}% CPU load
$tr requests currently being processed, $self->{IDLE} idle servers




\n";  




110




 





 





 





 





 





 



 ServerAddressReqIdleCPUAccessesTraffic 




111




 





 





 





 





 





 



   




112




 





 





 





 





 





 



   




113




 





 





 





 





 





 



 DEBUT 




114




 





 





 





 





 





 



   




115




 





 





 





 





 





 



   




116




 





 





 





 





 





 



 #suite  




117




0





 





 





 





 





 



 my $sum = $self->{SUMMARY} ; 




118




0





 





 





 





 





 



 my %hs= %$sum; 




119




 





 





 





 





 





 



   




120




0





 





 





 





 





 



 my $ligne; 




121




0





 





 





 





 





 



     foreach (keys %hs ) { 




122




 





 





 





 





 





 



   




123




0





 





 





 





 





 



             my $pu =$hs{$_}{cpu}; 




124




0





 





 





 





 





 



         $pu= sprintf("%.3f",$pu); 




125




 





 





 





 





 





 



   




126




0





 





 





 





 





 



             my $tr = $hs{$_}{traffic}; 




127




 





 





 





 





 





 



   




128




0




  
  0
  




 





 





 





 



 if ($tr > 1023)  { 




129




0





 





 





 





 





 



         $tr= $tr/ 1024 ; 




130




0





 





 





 





 





 



         $tr= sprintf("%.2fGB",$tr); 




131




 





 





 





 





 





 



   }  else { 




132




0





 





 





 





 





 



           $tr.="MB"; 




133




 





 





 





 





 





 



   } 




134




0





 





 





 





 





 



         $ligne .= "$_$self->{$_}$hs{$_}{request}"; 




135




0





 





 





 





 





 



 $ligne.="$hs{$_}{idle}$pu%$hs{$_}{accesses}$tr




136




 





 





 





 





 





 



     } 




137




 





 





 





 





 





 



   




138




0





 





 





 





 





 



 $message.=$ligne; 




139




 





 





 





 





 





 



   




140




 





 





 





 





 





 



   




141




0





 





 





 





 





 



          $message.=<




142



DEBUT


#suite
my $sum = $self->{SUMMARY} ;
my %hs= %$sum;

my $ligne;
    foreach (keys %hs ) {

            my $pu =$hs{$_}{cpu};
        $pu= sprintf("%.3f",$pu);

            my $tr = $hs{$_}{traffic};

if ($tr > 1023)  {
        $tr= $tr/ 1024 ;
        $tr= sprintf("%.2fGB",$tr);
  }  else {
          $tr.="MB";
  }
        $ligne .= "
$ligne.="$hs{$_}{idle}
    }

$message.=$ligne;


         $message.=<


tIN

if   ( $self->{STATUS} ne "NORMAL" ) {
$message.=<

SERVER NO AVAILABLE
sy

my $hu= $self->{RESULT} ;
my $li;
foreach (keys %$hu )  {
if ($hu->{$_} =~ /^UN/) {
 $li.="$_ $self->{$_}";
}
}
$message.=$li;
}

$message.=<





FIN


return $message;
1;




}
sub collect {
    my $node =shift;
    my $browser =LWP::UserAgent->new();
   my  $url= "http://$node/server-status";
   my $response = $browser->get($url);
   return "UNAVAILABLE"  unless $response->is_success();
   my $content = $response->content();
   return $content ;




}
sub analyze {
    my $self = shift;
   my $host =$self->{RESULT} ;
    my %res;
  my $ta;
    $self->{MIN} = 999;
    $self->{MAX} =0;
##########

    my $cp;
    my $tres;
    my $tchiffre;
    my $ti;
    my $tcpu;
  foreach (keys %$host) {
      next if $host->{$_} =~ /^UNA/ ;
  $cp++;
### request ####
   (my $resquest )= ($host->{$_}=~ /(\d+) requests curr/) ;
		    $res{$_}{request}= $resquest-1; # -1 : request for server-status
      $tres +=$resquest-1;
### traffic ###
   (my $chiffre,my $unite) = ($host->{$_}=~ /Total Traffic: (.+?) (MB|GB|kB|B)/);
if ($unite eq 'GB') { $chiffre = $chiffre * 1024    }
if ($unite eq 'B') { $chiffre =0  }
if ($unite eq 'kB') { $chiffre=$chiffre / 1024  }
      $chiffre =sprintf ("%.2f",$chiffre);
      $tchiffre += $chiffre;
      $res{$_}{traffic}  = $chiffre;
### accesses ###
 (my $accesses) =  ($host->{$_}=~ /Total accesses: (\d+)/) ;
 $res{$_}{accesses} = $accesses ;
      $ta  += $accesses;
### idle ###
 (my $idle) =  ($host->{$_}=~ /(\d+) idle servers/) ;
 $res{$_}{idle} = $idle +1 ;
      $ti  += $idle +1 ;
### CPU ###
(my $cpu) = ($host->{$_} =~ /Usage.+-(.+)% CPU load/);
$tcpu+= $cpu;
$res{$_}{cpu} =$cpu;
$self->{MIN} = $cpu if $cpu < $self->{MIN};
$self->{MAX} = $cpu if $cpu > $self->{MAX};



}

     $self->{SUMMARY} = \%res;
#### totalization ###
    $self->{STATUS} ="NORMAL";
    if ($self->{NODES} != $cp) {
	$self->{STATUS}  = 'WARNING'; }
    $self->{ACCESSES} = $ta ;
    $self->{TNODES} = "$cp/$self->{NODES}";
    $self->{TREQUEST} = $tres;
    $self->{TMB} = $tchiffre;
    $self->{IDLE} = $ti;
$self->{CPU} = $tcpu;
$self->{MOY}=0;
$self->{MOY} = $self->{CPU} / $cp if $cp ;
$self->{MOY} = sprintf ("%.3f",$self->{MOY});
$self->{MIN} = sprintf ("%.3f",$self->{MIN});
$self->{MAX} = sprintf ("%.3f",$self->{MAX});
     return 1;

}







1;
__END__