Changeset 2

Show
Ignore:
Timestamp:
11/19/07 03:56:22 (1 year ago)
Author:
twidi
Message:

premier jet version 1.5 avec fonctionnement possible en mode demon

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • sys_alive.conf

    r1 r2  
    2929####  CONFIGURATION  #### 
    3030#------------------------------------------------------------------------------# 
     31 
     32# mode demon ? 
     33%mode_demon = ( 
     34        'actif'    => 1, 
     35        'name'     => 'sys_alived', 
     36        'pid_file' => '/var/run/sys_alived.pid', 
     37); 
    3138 
    3239# les répertoires de logs et de données, à remplacer si différent du repertoire de conf, par défaut le même que sys_alive.pl 

  • sys_alive.pl

    r1 r2  
    11#!/usr/bin/perl 
    22############################################################### 
    3 #                  sys_alive.pl  v1.2.8                       # 
     3#                  sys_alive.pl  v1.5                         # 
    44############################################################### 
    55#    Programme de surveillance de serveur web sous Linux      # 
    …… 
    2727############################################################### 
    2828# Historique :                                                # 
     29# v 1.5  : 2007-11-19 : version "deamon"                      # 
    2930# v 1.2.8: 2007-05-07 : Séparation rép conf, data & log       # 
    3031#                       + affichage "ps faux" au lieu de top  # 
    …… 
    7576use strict; 
    7677 
     78use Proc::Daemon; 
     79use Proc::PID_File; 
     80use Sys::Syslog qw(:standard :macros); 
     81 
     82Proc::Daemon::Init; 
     83 
    7784#------------------------------------------------------------------------------# 
    7885# répertoire des données : remplacer *éventuellement* GetLocalRep() par 
    …… 
    8188 
    8289my $rep_conf = GetLocalRep(); 
    83  
    8490#------------------------------------------------------------------------------# 
    8591 
    …… 
    94100$main::rep_log  = $rep_conf if !$main::rep_log; 
    95101 
    96 # variables 
    97 my $version = '1.2.8'; 
     102# variables globales 
     103my $version = '1.5'; 
    98104my $arg = lc(shift(@ARGV)); 
    99105if (!$main::logfile) { $main::logfile = $main::rep_log.'/sys_alive.log'; } 
    100106my $datafile = $main::rep_data.'/sys_alive.dat'; 
    101107my %infos = LireFichier(); 
    102 my @alertes; 
    103 my $alertes_niveau2 = 0; 
    104 my $alerte_importante = 0; 
    105 my %data; 
    106 my @killed_process; 
    107 my @restarted_demons; 
    108 my %process; 
    109108my %ignore; 
    110109 
    …… 
    120119} 
    121120 
    122 # on ne vas gérer le tout que si sys_alive n'est pas stoppé 
    123 if (!$infos{'stopped'}) { 
    124         # récupération des données 
    125         my %datetime = GetTime(); 
    126         ($data{'ram_physique'}, $data{'ram_reelle'}, $data{'ram_swap'}) = GetInfosRam(); 
    127         ($data{'cpu_1'}, $data{'cpu_5'}, $data{'cpu_15'}, $data{'nb_process'}) = GetInfosCPU(); 
    128         my $top = `$term top b n 1`; # récupération des process 
    129         my $free = `free -t`; 
    130  
    131         ###### gestion des alertes 
    132         if ($main::gestion{'seuil_alerte'}) { 
    133  
    134                 # gestion de l'alerte swap 
    135                 if ($main::seuil_alertes{'swap'}) { 
    136                         if ($data{'ram_swap'} > $main::seuil_alertes{'swap'}) { # en cas de dépassement 
    137                                 push @alertes, 'swap'; 
    138                                 WriteLog("Seuil 1 du swap dépassé : $data{'ram_swap'} > $main::seuil_alertes{'swap'}"); 
    139                         } # fin de if data > seuil 
    140                 } # fin de if swap 
    141  
    142                 # gestion de l'alerte load_average 
    143                 if ($main::seuil_alertes{'load_average'}) { 
    144                         if ($data{'cpu_1'} > $main::seuil_alertes{'load_average'}) { # en cas de dépassement 
    145                                 push @alertes, 'load_average'; 
    146                                 WriteLog("Seuil 1 du load average dépassé : $data{'cpu_1'} > $main::seuil_alertes{'load_average'}"); 
    147                         } # fin de if data > seuil 
    148                 } # fin de if load_average 
    149  
    150                 # gestion de l'alerte nb_process 
    151                 if ($main::seuil_alertes{'nb_process'}) { 
    152                         if ($data{'nb_process'} > $main::seuil_alertes{'nb_process'}) { # en cas de dépassement 
    153                                 push @alertes, 'nb_process'; 
    154                                 WriteLog("Seuil 1 du nb de process dépassé : $data{'nb_process'} > $main::seuil_alertes{'nb_process'}"); 
    155                         } # fin de if data > seuil 
    156                 } # fin de if nb_process 
    157  
    158         } # fin de if gestion seuil_alerte 
    159  
    160         #### si on a enregistré des alertes, avant les kills éventuels on va récupérer certaines valeurs du systÚme 
    161         my ($mysql_activity_msg, $apache_activity_msg); 
    162         if (@alertes+0) { 
    163                 if ($main::mysql_activity) {    $mysql_activity_msg = Execute($main::mysql_activity, 1); } 
    164                 if ($main::apache_activity) {   $apache_activity_msg = Execute($main::apache_activity, 1); } 
    165         } # fin de if alertes 
    166  
    167  
    168         ###### gestion des alertes de niveau 2 
    169         if ($main::gestion{'stop_alerte'}) { 
    170  
    171                 # gestion de l'alerte swap 
    172                 if ($main::seuil_alertes_niveau2{'swap'}) { 
    173                         if ($data{'ram_swap'} > $main::seuil_alertes_niveau2{'swap'}) { # en cas de dépassement 
    174                                 if (!$alertes_niveau2) { unshift @alertes, '--ALERTE--'; } 
    175                                 $alertes_niveau2++; 
    176                                 $alerte_importante = 1; 
    177                                 WriteLog("Seuil 2 du swap dépassé : $data{'ram_swap'} > $main::seuil_alertes_niveau2{'swap'}"); 
    178                         } # fin de if data > seuil 
    179                 } # fin de if swap 
    180  
    181                 # gestion de l'alerte load_average 
    182                 if ($main::seuil_alertes_niveau2{'load_average'}) { 
    183                         if ($data{'cpu_1'} > $main::seuil_alertes_niveau2{'load_average'}) { # en cas de dépassement 
    184                                 if (!$alertes_niveau2) { unshift @alertes, '--ALERTE--'; } 
    185                                 $alertes_niveau2++; 
    186                                 $alerte_importante = 1; 
    187                                 WriteLog("Seuil 2 du load average dépassé : $data{'cpu_1'} > $main::seuil_alertes_niveau2{'load_average'}"); 
    188                         } # fin de if data > seuil 
    189                 } # fin de if load_average 
    190  
    191                 # gestion de l'alerte nb_process 
    192                 if ($main::seuil_alertes_niveau2{'nb_process'}) { 
    193                         if ($data{'nb_process'} > $main::seuil_alertes_niveau2{'nb_process'}) { # en cas de dépassement 
    194                                 if (!$alertes_niveau2) { unshift @alertes, '--ALERTE--'; } 
    195                                 $alertes_niveau2++; 
    196                                 $alerte_importante = 1; 
    197                                 WriteLog("Seuil 2 du nb de process dépassé : $data{'nb_process'} > $main::seuil_alertes_niveau2{'nb_process'}"); 
    198                         } # fin de if data > seuil 
    199                 } # fin de if nb_process 
    200  
    201                 # si on est en alerte niveau 2, on va stopper les démons à stopper 
    202                 if ($alertes_niveau2) { 
    203                         foreach my $demon (keys(%main::demons_to_stop)) { # pour chaque demon 
    204                         if (!IgnoreDemon($demon)) { # si on ne doit pas l'ignorer 
    205                                 my $canstop = ($top =~ /\s$demon\s*$/m); # on arrete le demon s'il est lancé 
    206                                 SetInfo('skip_demon_'.$demon, time(), 1); # on met le demon dans la liste des démons à ne pas relancer 
    207                                 if ($canstop) { 
    208                                         WriteLog("Alerte de niveau 2 : arrêt de $demon pour $main::demons_to_stop{$demon} secondes"); 
    209                                         Execute($main::demons_stop{$demon}); 
    210                                 } else { 
    211                                         WriteLog("Alerte de niveau 2 : impossible de stopper $demon car il n'est pas lancé"); 
    212                                 } 
    213                         } # fin de if !ignore 
     121if ($main::mode_demon{'actif'}) { 
     122        mode_demon(); 
     123} else { 
     124        sys_alive(); 
     125} 
     126exit; 
     127 
     128# mode demon 
     129sub mode_demon { 
     130        my $current_pid; 
     131        eval { $current_pid = hold_pid_file($main::mode_demon{'pid_file'}); }; 
     132        WriteLog('ProblÚme en accédant au fichier pid : '.$@, 1) if $@; 
     133        WriteLog('Sys_alive est déjà lancé en mode démon (pid='.$current_pid.')', 1) if $current_pid; 
     134        WriteLog('Sys_alive lancé en mode démon (pid='.$$.')'); 
     135        while(1) { 
     136                sys_alive(); 
     137                sleep 60; 
     138        } 
     139} # fin de sub mode_demon 
     140 
     141 
     142# fonction principale 
     143sub sys_alive { 
     144 
     145        # variables locales 
     146        my @alertes; 
     147        my $alertes_niveau2 = 0; 
     148        my $alerte_importante = 0; 
     149        my %data; 
     150        my @killed_process; 
     151        my @restarted_demons; 
     152        my %process; 
     153 
     154        # on ne vas gérer le tout que si sys_alive n'est pas stoppé 
     155        if (!$infos{'stopped'}) { 
     156                # récupération des données 
     157                my %datetime = GetTime(); 
     158                ($data{'ram_physique'}, $data{'ram_reelle'}, $data{'ram_swap'}) = GetInfosRam(); 
     159                ($data{'cpu_1'}, $data{'cpu_5'}, $data{'cpu_15'}, $data{'nb_process'}) = GetInfosCPU(); 
     160                my $top = `$term top b n 1`; # récupération des process 
     161                my $free = `free -t`; 
     162 
     163                ###### gestion des alertes 
     164                if ($main::gestion{'seuil_alerte'}) { 
     165 
     166                        # gestion de l'alerte swap 
     167                        if ($main::seuil_alertes{'swap'}) { 
     168                                if ($data{'ram_swap'} > $main::seuil_alertes{'swap'}) { # en cas de dépassement 
     169                                        push @alertes, 'swap'; 
     170                                        WriteLog("Seuil 1 du swap dépassé : $data{'ram_swap'} > $main::seuil_alertes{'swap'}"); 
     171                                } # fin de if data > seuil 
     172                        } # fin de if swap 
     173 
     174                        # gestion de l'alerte load_average 
     175                        if ($main::seuil_alertes{'load_average'}) { 
     176                                if ($data{'cpu_1'} > $main::seuil_alertes{'load_average'}) { # en cas de dépassement 
     177                                        push @alertes, 'load_average'; 
     178                                        WriteLog("Seuil 1 du load average dépassé : $data{'cpu_1'} > $main::seuil_alertes{'load_average'}"); 
     179                                } # fin de if data > seuil 
     180                        } # fin de if load_average 
     181 
     182                        # gestion de l'alerte nb_process 
     183                        if ($main::seuil_alertes{'nb_process'}) { 
     184                                if ($data{'nb_process'} > $main::seuil_alertes{'nb_process'}) { # en cas de dépassement 
     185                                        push @alertes, 'nb_process'; 
     186                                        WriteLog("Seuil 1 du nb de process dépassé : $data{'nb_process'} > $main::seuil_alertes{'nb_process'}"); 
     187                                } # fin de if data > seuil 
     188                        } # fin de if nb_process 
     189 
     190                } # fin de if gestion seuil_alerte 
     191 
     192                #### si on a enregistré des alertes, avant les kills éventuels on va récupérer certaines valeurs du systÚme 
     193                my ($mysql_activity_msg, $apache_activity_msg); 
     194                if (@alertes+0) { 
     195                        if ($main::mysql_activity) {    $mysql_activity_msg = Execute($main::mysql_activity, 1); } 
     196                        if ($main::apache_activity) {   $apache_activity_msg = Execute($main::apache_activity, 1); } 
     197                } # fin de if alertes 
     198 
     199 
     200                ###### gestion des alertes de niveau 2 
     201                if ($main::gestion{'stop_alerte'}) { 
     202 
     203                        # gestion de l'alerte swap 
     204                        if ($main::seuil_alertes_niveau2{'swap'}) { 
     205                                if ($data{'ram_swap'} > $main::seuil_alertes_niveau2{'swap'}) { # en cas de dépassement 
     206                                        if (!$alertes_niveau2) { unshift @alertes, '--ALERTE--'; } 
     207                                        $alertes_niveau2++; 
     208                                        $alerte_importante = 1; 
     209                                        WriteLog("Seuil 2 du swap dépassé : $data{'ram_swap'} > $main::seuil_alertes_niveau2{'swap'}"); 
     210                                } # fin de if data > seuil 
     211                        } # fin de if swap 
     212 
     213                        # gestion de l'alerte load_average 
     214                        if ($main::seuil_alertes_niveau2{'load_average'}) { 
     215                                if ($data{'cpu_1'} > $main::seuil_alertes_niveau2{'load_average'}) { # en cas de dépassement 
     216                                        if (!$alertes_niveau2) { unshift @alertes, '--ALERTE--'; } 
     217                                        $alertes_niveau2++; 
     218                                        $alerte_importante = 1; 
     219                                        WriteLog("Seuil 2 du load average dépassé : $data{'cpu_1'} > $main::seuil_alertes_niveau2{'load_average'}"); 
     220                                } # fin de if data > seuil 
     221                        } # fin de if load_average 
     222 
     223                        # gestion de l'alerte nb_process 
     224                        if ($main::seuil_alertes_niveau2{'nb_process'}) { 
     225                                if ($data{'nb_process'} > $main::seuil_alertes_niveau2{'nb_process'}) { # en cas de dépassement 
     226                                        if (!$alertes_niveau2) { unshift @alertes, '--ALERTE--'; } 
     227                                        $alertes_niveau2++; 
     228                                        $alerte_importante = 1; 
     229                                        WriteLog("Seuil 2 du nb de process dépassé : $data{'nb_process'} > $main::seuil_alertes_niveau2{'nb_process'}"); 
     230                                } # fin de if data > seuil 
     231                        } # fin de if nb_process 
     232 
     233                        # si on est en alerte niveau 2, on va stopper les démons à stopper 
     234                        if ($alertes_niveau2) { 
     235                                foreach my $demon (keys(%main::demons_to_stop)) { # pour chaque demon 
     236                                if (!IgnoreDemon($demon)) { # si on ne doit pas l'ignorer 
     237                                        my $canstop = ($top =~ /\s$demon\s*$/m); # on arrete le demon s'il est lancé 
     238                                        SetInfo('skip_demon_'.$demon, time(), 1); # on met le demon dans la liste des démons à ne pas relancer 
     239                                        if ($canstop) { 
     240                                                WriteLog("Alerte de niveau 2 : arrêt de $demon pour $main::demons_to_stop{$demon} secondes"); 
     241                                                Execute($main::demons_stop{$demon}); 
     242                                        } else { 
     243                                                WriteLog("Alerte de niveau 2 : impossible de stopper $demon car il n'est pas lancé"); 
     244                                        } 
     245                                } # fin de if !ignore 
     246                                } # fin de foreach 
     247                        } # fin de if 
     248 
     249                } # fin de if gestion stop_alerte 
     250 
     251                ###### gestion des process trop longs 
     252                if ($main::gestion{'kill_process'} or $main::gestion{'reload_demons'}) { 
     253 
     254                        # préparation du top à être interprété 
     255                        my @top = split(/\n/, $top); 
     256                        splice(@top, 0, 7); 
     257                        chomp(@top); 
     258                        # travail sur chaque ligne 
     259                        foreach my $ligne (@top) { 
     260                                if ($ligne =~ /(\d+)\s*(\w*)\s*.*?((\d*):(\d*\.?\d*)) (.*?)\s*$/) { 
     261                                        my %info_process = ( 
     262                                                pid => $1, 
     263                                                user => $2, 
     264                                                duree => $3, 
     265                                                minutes => $4, 
     266                                                secondes => $5, 
     267                                                process => $6, 
     268                                        ); 
     269                                        # recherche des demons à relancés 
     270                                        if ($main::gestion{'reload_demons'}) { 
     271                                                # on enregistre le fait que ce process est lancé 
     272                                                $process{$info_process{'process'}}->{'present'} = 1; 
     273                                                # et l'utilisateur concerné 
     274                                                $process{$info_process{'process'}}->{$info_process{'user'}} = 1; 
     275                                        } # fin de gestion reload demons 
     276 
     277                                        # recherche des process à killer 
     278                                        if ($main::gestion{'kill_process'}) { 
     279                                                $info_process{'nb_sec'} = $info_process{'minutes'} * 60 + $info_process{'secondes'}; # calcul du nb de secondes 
     280                                                # en cas de process trop long 
     281                                                if ($info_process{'nb_sec'} > $main::delai_max_process) { 
     282                                                        my $to_del = 0; 
     283                                                        # on regarde s'il est à tuer 
     284                                                        foreach my $to_kill (@main::process_to_kill) { if ($info_process{'process'} =~ /$to_kill/) { $to_del = 1; } } 
     285                                                        # on regarde s'il est à garder 
     286                                                        foreach my $to_keep (@main::process_to_keep) { if ($info_process{'process'} =~ /$to_keep/) { $to_del = 0; } } 
     287                                                        # on ne tue le process root que si autorisé 
     288                                                        if (($info_process{'user'} eq 'root') and (!$main::kill_root_process)) {        $to_del = 0; } 
     289                                                        # on tue le process... 
     290                                                        if ($to_del) { # s'il est à tuer 
     291                                                                push @killed_process, \%info_process; # on sauvegarde l'info 
     292                                                                $alerte_importante = 1; # pour forcer l'envoie de mail quelque soit le délai entre les mails 
     293                                                                WriteLog("Process $info_process{'process'} tué car trop long (durée=$info_process{'duree'}, pid=$info_process{'pid'}, user=$info_process{'user'})"); 
     294                                                                Execute("kill -9 $info_process{'pid'}"); # on kill le process 
     295                                                        } # fin de if to_del 
     296                                                } # fin de if info_process > alerte 
     297                                        } # fin de if kill_process 
     298                                } # fin de if ligne =~ 
    214299                        } # fin de foreach 
    215                 } # fin de if 
    216  
    217         } # fin de if gestion stop_alerte 
    218  
    219         ###### gestion des process trop longs 
    220         if ($main::gestion{'kill_process'} or $main::gestion{'reload_demons'}) { 
    221  
    222                 # préparation du top à être interprété 
    223                 my @top = split(/\n/, $top); 
    224                 splice(@top, 0, 7); 
    225                 chomp(@top); 
    226                 # travail sur chaque ligne 
    227                 foreach my $ligne (@top) { 
    228                         if ($ligne =~ /(\d+)\s*(\w*)\s*.*?((\d*):(\d*\.?\d*)) (.*?)\s*$/) { 
    229                                 my %info_process = ( 
    230                                         pid => $1, 
    231                                         user => $2, 
    232                                         duree => $3, 
    233                                         minutes => $4, 
    234                                         secondes => $5, 
    235                                         process => $6, 
    236                                 ); 
    237                                 # recherche des demons à relancés 
    238                                 if ($main::gestion{'reload_demons'}) { 
    239                                         # on enregistre le fait que ce process est lancé 
    240                                         $process{$info_process{'process'}}->{'present'} = 1; 
    241                                         # et l'utilisateur concerné 
    242                                         $process{$info_process{'process'}}->{$info_process{'user'}} = 1; 
    243                                 } # fin de gestion reload demons 
    244  
    245                                 # recherche des process à killer 
    246                                 if ($main::gestion{'kill_process'}) { 
    247                                         $info_process{'nb_sec'} = $info_process{'minutes'} * 60 + $info_process{'secondes'}; # calcul du nb de secondes 
    248                                         # en cas de process trop long 
    249                                         if ($info_process{'nb_sec'} > $main::delai_max_process) { 
    250                                                 my $to_del = 0; 
    251                                                 # on regarde s'il est à tuer 
    252                                                 foreach my $to_kill (@main::process_to_kill) { if ($info_process{'process'} =~ /$to_kill/) { $to_del = 1; } } 
    253                                                 # on regarde s'il est à garder 
    254                                                 foreach my $to_keep (@main::process_to_keep) { if ($info_process{'process'} =~ /$to_keep/) { $to_del = 0; } } 
    255                                                 # on ne tue le process root que si autorisé 
    256                                                 if (($info_process{'user'} eq 'root') and (!$main::kill_root_process)) {        $to_del = 0; } 
    257                                                 # on tue le process... 
    258                                                 if ($to_del) { # s'il est à tuer 
    259                                                         push @killed_process, \%info_process; # on sauvegarde l'info 
    260                                                         $alerte_importante = 1; # pour forcer l'envoie de mail quelque soit le délai entre les mails 
    261                                                         WriteLog("Process $info_process{'process'} tué car trop long (durée=$info_process{'duree'}, pid=$info_process{'pid'}, user=$info_process{'user'})"); 
    262                                                         Execute("kill -9 $info_process{'pid'}"); # on kill le process 
    263                                                 } # fin de if to_del 
    264                                         } # fin de if info_process > alerte 
    265                                 } # fin de if kill_process 
    266                         } # fin de if ligne =~ 
    267                 } # fin de foreach 
    268                 if (@killed_process+0 > 0) { push @alertes, 'kill'; } 
    269         } # fin de if gesion kill_process or gestion reload_demons 
    270  
    271         ###### gestion des demons 
    272         if ($main::gestion{'reload_demons'}) { 
    273                 # on va gerer chaque demon 
    274                 foreach my $demon (keys(%main::demons_start)) { if (defined($demon)) { 
    275                         if (!IgnoreDemon($demon)) { # si on ne doit pas l'ignorer 
    276                                 # check du demon 
    277                                 my $present = ($process{$demon}->{'present'} and (defined($main::demons_user{$demon}) ? $process{$demon}->{$main::demons_user{$demon}} : 1)); 
    278                                 # si le demon n'est pas présent et qu'il n'est pas à l'état "skip" 
    279                                 if (!$present and ($infos{'skip_demon_'.$demon} + $main::demons_to_stop{$demon} < time())) { 
    280                                         push @restarted_demons, $demon; # sauvegarde de l'information 
    281                                         $alerte_importante = 1; # pour forcer l'envoie de mail quelque soit le délai entre les mails 
    282                                         if ($infos{'skip_demon_'.$demon}) { 
    283                                                 WriteLog("Démon $demon relancé, durée de $main::demons_to_stop{$demon} secondes écoulée"); 
    284                                         } else { 
    285                                                 WriteLog("Démon $demon relancé car absent"); 
    286                                         } 
    287                                         SetInfo('skip_demon_'.$demon, 0); # on annule l'état "skip" s'il y etait 
    288                                         Execute($main::demons_start{$demon}); # on relance le demon 
    289                                 } #fin de if 
    290                         } # fin de if !ignore 
    291                 }} # fin de foreach demon if defined 
    292                 if (@restarted_demons+0 > 0) { push @alertes, 'demon'; } 
    293         } # fin de if gesion reload_demons 
    294  
    295         ###### envoi du mail (si alerte importante ou ecart entre 2 mails respecté) 
    296         if (!$alerte_importante and ((@alertes+0 > 0) and ($datetime{'nb_sec'} - $infos{'date_msg'} < $main::ecart_alerte))) { 
    297                 WriteLog(" -> Aucun mail envoyé car le dernier date de moins de $main::ecart_alerte secondes"); 
    298         } 
    299         if ($alerte_importante or ((@alertes+0 > 0) and ($datetime{'nb_sec'} - $infos{'date_msg'} >= $main::ecart_alerte))) { 
    300                 # alerte de niveau 2 
    301                 my ($alerte2, $alerte2sms); 
    302                 if ($alertes_niveau2) { 
    303                         $alerte2 = "\nIMPORTANT : Une alerte de niveau 2 a été détectée. Les démons suivants ont été arrétés :\n"; 
    304                         $alerte2sms = "Démons tués:"; 
    305                         foreach my $demon (keys(%main::demons_to_stop)) { # pour chaque demon 
     300                        if (@killed_process+0 > 0) { push @alertes, 'kill'; } 
     301                } # fin de if gesion kill_process or gestion reload_demons 
     302 
     303                ###### gestion des demons 
     304                if ($main::gestion{'reload_demons'}) { 
     305                        # on va gerer chaque demon 
     306                        foreach my $demon (keys(%main::demons_start)) { if (defined($demon)) { 
    306307                                if (!IgnoreDemon($demon)) { # si on ne doit pas l'ignorer 
    307                                         $alerte2 .= $demon.' ('.$main::demons_to_stop{$demon}.' secondes.) - '; 
    308                                         $alerte2sms .= "$demon,"; 
     308                                        # check du demon 
     309                                        my $present = ($process{$demon}->{'present'} and (defined($main::demons_user{$demon}) ? $process{$demon}->{$main::demons_user{$demon}} : 1)); 
     310                                        # si le demon n'est pas présent et qu'il n'est pas à l'état "skip" 
     311                                        if (!$present and ($infos{'skip_demon_'.$demon} + $main::demons_to_stop{$demon} < time())) { 
     312                                                push @restarted_demons, $demon; # sauvegarde de l'information 
     313                                                $alerte_importante = 1; # pour forcer l'envoie de mail quelque soit le délai entre les mails 
     314                                                if ($infos{'skip_demon_'.$demon}) { 
     315                                                        WriteLog("Démon $demon relancé, durée de $main::demons_to_stop{$demon} secondes écoulée"); 
     316                                                } else { 
     317                                                        WriteLog("Démon $demon relancé car absent"); 
     318                                                } 
     319                                                SetInfo('skip_demon_'.$demon, 0); # on annule l'état "skip" s'il y etait 
     320                                                Execute($main::demons_start{$demon}); # on relance le demon 
     321                                        } #fin de if 
    309322                                } # fin de if !ignore 
    310                         } # fin de foreach 
    311                         $alerte2 .= "\n"; 
     323                        }} # fin de foreach demon if defined 
     324                        if (@restarted_demons+0 > 0) { push @alertes, 'demon'; } 
     325                } # fin de if gesion reload_demons 
     326 
     327                ###### envoi du mail (si alerte importante ou ecart entre 2 mails respecté) 
     328                if (!$alerte_importante and ((@alertes+0 > 0) and ($datetime{'nb_sec'} - $infos{'date_msg'} < $main::ecart_alerte))) { 
     329                        WriteLog(" -> Aucun mail envoyé car le dernier date de moins de $main::ecart_alerte secondes"); 
    312330                } 
    313                 # composition du message 
    314                 my $proc_activity_msg = $main::proc_activity ? Execute($main::proc_activity, 1) : $top; 
    315                 my $msg_mail = <<"ENDMAIL"; 
     331                if ($alerte_importante or ((@alertes+0 > 0) and ($datetime{'nb_sec'} - $infos{'date_msg'} >= $main::ecart_alerte))) { 
     332                        # alerte de niveau 2 
     333                        my ($alerte2, $alerte2sms); 
     334                        if ($alertes_niveau2) { 
     335                                $alerte2 = "\nIMPORTANT : Une alerte de niveau 2 a été détectée. Les démons suivants ont été arrétés :\n"; 
     336                                $alerte2sms = "Démons tués:"; 
     337                                foreach my $demon (keys(%main::demons_to_stop)) { # pour chaque demon 
     338                                        if (!IgnoreDemon($demon)) { # si on ne doit pas l'ignorer 
     339                                                $alerte2 .= $demon.' ('.$main::demons_to_stop{$demon}.' secondes.) - '; 
     340                                                $alerte2sms .= "$demon,"; 
     341                                        } # fin de if !ignore 
     342                                } # fin de foreach 
     343                                $alerte2 .= "\n"; 
     344                        } 
     345                        # composition du message 
     346                        my $proc_activity_msg = $main::proc_activity ? Execute($main::proc_activity, 1) : $top; 
     347                        my $msg_mail = <<"ENDMAIL"; 
    316348 
    317349Alerte du $datetime{'date'} à $datetime{'hour'}h$datetime{'min'} 
    …… 
    346378ENDSMS 
    347379 
    348                 # ajout des infos sur les process tués 
    349                 if (@killed_process+0 > 0) { 
    350                         $msg_mail .= "\nListe des process tués :\n------------------------\n"; 
    351                         my $nb_process_killed = @killed_process+0; 
    352                         $msg_sms .= "\nKilled: "; 
    353                         foreach my $process (@killed_process) { # pour chaque process 
    354                                 $msg_mail .= " - Process : $process->{'process'}, User : $process->{'user'}, PID : $process->{'pid'}, Durée : $process->{'minutes'}:$process->{'secondes'}\n"; 
    355                                 $msg_sms .= "$process->{'process'}($process->{'user'}),"; 
    356                         } # fin de foreach process 
    357                 } # fin de if @killed_process 
    358  
    359                 # ajout des infos sur les démons relancés 
    360                 if (@restarted_demons+0 > 0) { 
    361                         $msg_mail .= "\nListe des démons relancés :\n-----------------------------\n"; 
    362                         $msg_sms .= "\nDemons: "; 
    363                         foreach my $demon (@restarted_demons) { # pour chaque démon 
    364                                 $msg_mail .= " - $demon\n"; 
    365                                 $msg_sms .= "$demon,"; 
    366                         } # fin de foreach demon 
    367                         $msg_sms = substr($msg_sms, 0, length($msg_sms)-1); 
    368                 } # fin de if @restarted_demons 
    369  
    370                 # ajout de l'alerte 2 pour les sms 
    371                 $msg_sms .= "\n".$alerte2sms; 
    372  
    373                 # 20 derniÚres lignes de log 
    374                 if ($main::joint_log) { 
    375                         sleep(10); 
    376                         my $tail_log = qx(tail -n20 $main::logfile); 
    377                         $msg_mail .= "\nLog :\n-----\n".$tail_log; 
    378                 } 
    379  
    380  
    381                 if ($mysql_activity_msg) { 
    382                         $msg_mail .= <<"ENDMAIL"; 
     380                       # ajout des infos sur les process tués 
     381                       if (@killed_process+0 > 0) { 
     382                               $msg_mail .= "\nListe des process tués :\n------------------------\n"; 
     383                               my $nb_process_killed = @killed_process+0; 
     384                               $msg_sms .= "\nKilled: "; 
     385                               foreach my $process (@killed_process) { # pour chaque process 
     386                                       $msg_mail .= " - Process : $process->{'process'}, User : $process->{'user'}, PID : $process->{'pid'}, Durée : $process->{'minutes'}:$process->{'secondes'}\n"; 
     387                                       $msg_sms .= "$process->{'process'}($process->{'user'}),"; 
     388                               } # fin de foreach process 
     389                       } # fin de if @killed_process 
     390 
     391                       # ajout des infos sur les démons relancés 
     392                       if (@restarted_demons+0 > 0) { 
     393                               $msg_mail .= "\nListe des démons relancés :\n-----------------------------\n"; 
     394                               $msg_sms .= "\nDemons: "; 
     395                               foreach my $demon (@restarted_demons) { # pour chaque démon 
     396                                       $msg_mail .= " - $demon\n"; 
     397                                       $msg_sms .= "$demon,"; 
     398                               } # fin de foreach demon 
     399                               $msg_sms = substr($msg_sms, 0, length($msg_sms)-1); 
     400                       } # fin de if @restarted_demons 
     401 
     402                       # ajout de l'alerte 2 pour les sms 
     403                       $msg_sms .= "\n".$alerte2sms; 
     404 
     405                       # 20 derniÚres lignes de log 
     406                       if ($main::joint_log) { 
     407                               sleep(10); 
     408                               my $tail_log = qx(tail -n20 $main::logfile); 
     409                               $msg_mail .= "\nLog :\n-----\n".$tail_log; 
     410                       } 
     411 
     412 
     413                       if ($mysql_activity_msg) { 
     414                               $msg_mail .= <<"ENDMAIL"; 
    383415 
    384416 
    …… 
    387419$mysql_activity_msg 
    388420ENDMAIL 
    389                 } 
    390  
    391                 if ($apache_activity_msg) { 
    392                         $msg_mail .= <<"ENDMAIL"; 
     421                       } 
     422 
     423                       if ($apache_activity_msg) { 
     424                               $msg_mail .= <<"ENDMAIL"; 
    393425 
    394426 
    …… 
    397429$apache_activity_msg 
    398430ENDMAIL 
    399                 } 
    400  
    401                 $msg_mail .= <<"ENDFINMAIL"; 
     431                       } 
     432 
     433                       $msg_mail .= <<"ENDFINMAIL"; 
    402434 
    403435-- 
    …… 
    406438ENDFINMAIL 
    407439 
    408                 # composition du sujet 
    409                 my $sujet = 'Alerte'; 
    410                 foreach (@alertes) { $sujet .= ' '.$_; }; 
    411  
    412                 # envoi du mail 
    413                 my %mail = ( 
    414                         sujet => $sujet, 
    415                         msg => $msg_mail, 
    416                 ); 
    417                 foreach (@main::mails) { 
    418                         $mail{'to'} = $_; 
    419                         SendMail(%mail); 
    420                         WriteLog("Envoi d'un mail à $mail{'to'}"); 
    421                 } 
    422  
    423                 # envoi du sms 
    424                 my %sms = ( 
    425                         sujet => $sujet, 
    426                         msg => $msg_sms, 
    427                 ); 
    428                 foreach (@main::mails_sms) { 
    429                         $sms{'to'} = $_; 
    430                         SendMail(%sms); 
    431                         WriteLog("Envoi d'un mail format sms à $sms{'to'}"); 
    432                 } 
    433  
    434                 # enregistrement de la date de dernier envoie de mail 
    435                 SetInfo('date_msg', time(), 1); 
    436  
    437         } # fin de if ... (envoi mail) 
    438  
    439 } # fin de if (!$infos{'stopped'}) { 
    440  
    441  
     440                       # composition du sujet 
     441                       my $sujet = 'Alerte'; 
     442                       foreach (@alertes) { $sujet .= ' '.$_; }; 
     443 
     444                       # envoi du mail 
     445                       my %mail = ( 
     446                               sujet => $sujet, 
     447                               msg => $msg_mail, 
     448                       ); 
     449                       foreach (@main::mails) { 
     450                               $mail{'to'} = $_; 
     451                               SendMail(%mail); 
     452                               WriteLog("Envoi d'un mail à $mail{'to'}"); 
     453                       } 
     454 
     455                       # envoi du sms 
     456                       my %sms = ( 
     457                               sujet => $sujet, 
     458                               msg => $msg_sms, 
     459                       ); 
     460                       foreach (@main::mails_sms) { 
     461                               $sms{'to'} = $_; 
     462                               SendMail(%sms); 
     463                               WriteLog("Envoi d'un mail format sms à $sms{'to'}"); 
     464                       } 
     465 
     466                       # enregistrement de la date de dernier envoie de mail 
     467                       SetInfo('date_msg', time(), 1); 
     468 
     469               } # fin de if ... (envoi mail) 
     470 
     471       } # fin de if (!$infos{'stopped'}) { 
     472 
     473} # fin de sub sys_alive 
    442474 
    443475#------------------------------------------------------------------------------# 
    …… 
    554586#------------------------------------------------------------------------------# 
    555587sub WriteLog { 
    556         my ($texte) = @_; 
     588        my ($texte, $die) = @_; 
    557589        LockFichier($main::logfile, 1); 
    558590        my %d = GetTime(); 
    …… 
    562594        close(LOG); 
    563595        LockFichier($main::logfile, 0); 
     596        die if $die; 
     597        return 1; 
    564598} 
    565599#------------------------------------------------------------------------------# 
    …… 
    569603#------------------------------------------------------------------------------# 
    570604sub GetLocalRep { 
    571         my $dir = $0; 
    572         ($dir) = split(/sys_alive\.pl/, $dir); 
    573         return $dir; 
     605        use FindBin qw($Bin); 
     606        return $Bin; 
    574607} 
    575608#------------------------------------------------------------------------------#