|
|
|
|
@ -1,6 +1,8 @@
|
|
|
|
|
#!/usr/bin/perl
|
|
|
|
|
#!/usr/local/bin/perl
|
|
|
|
|
use strict;
|
|
|
|
|
use warnings;
|
|
|
|
|
|
|
|
|
|
use English;
|
|
|
|
|
use File::Basename; ###---Package pour saisir le nom d un fichier (sans son repertoire)
|
|
|
|
|
use Cwd; ###---Package pour connaitre le repertoire courant
|
|
|
|
|
@ -53,7 +55,8 @@ my $PREC_RELATIVE_POURCENT = "1.e-3";#precision pour la comparaison relative (en
|
|
|
|
|
#####################################
|
|
|
|
|
#####################################
|
|
|
|
|
|
|
|
|
|
#taille maximale du fichier de redirection de l affichage d un calcul Herezh (en octets) rq : le but de cette limite est principalement de contrer le risque de remplissage du disque dur dans le cas ou Herezh affiche en boucle infinie dans le terminal
|
|
|
|
|
#taille maximale du fichier de redirection de l affichage d un calcul Herezh (en octets) rq : le but de cette limite est principalement de contrer le risque de remplissage du disque dur
|
|
|
|
|
# dans le cas ou Herezh affiche beaucoup trop de chose dans le terminal
|
|
|
|
|
# => fixee a 250 Mo le 2015-04-14
|
|
|
|
|
# Mo Ko
|
|
|
|
|
my $TAILLE_MAX_FIC_REDIR = 250*1024*1024;#octets
|
|
|
|
|
@ -422,9 +425,10 @@ BOUCLE_TEST:for(my $no_test=1; $no_test<=$nb_CVisu; $no_test++) {
|
|
|
|
|
|
|
|
|
|
my $status_calcul = lancement_commande($hzchemin, $cmd_HZ, "$fichier_test.log", $fic_commande);
|
|
|
|
|
|
|
|
|
|
# - si calcul a termine normalement (converge ou non) => $status_calcul = "ok"
|
|
|
|
|
# - si calcul a conduit a un trop gros fichier de redirection => $status_calcul = "depassement taille maximum"
|
|
|
|
|
# - si probleme de redirection d affichage => $status_calcul = "probleme redirection affichage"
|
|
|
|
|
# - si le calcul a termine normalement (converge ou non) => $status_calcul = "ok"
|
|
|
|
|
# - si le calcul a conduit a un trop gros fichier de redirection => $status_calcul = "depassement taille maximum"
|
|
|
|
|
# - si il y a eu un probleme de redirection d affichage => $status_calcul = "probleme redirection affichage"
|
|
|
|
|
# - si le calcul ne s arretait pas alors qu il avait une activite cpu nulle => $status_calcul = "activite cpu nulle"
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
#####################################################################################################
|
|
|
|
|
@ -446,6 +450,7 @@ BOUCLE_TEST:for(my $no_test=1; $no_test<=$nb_CVisu; $no_test++) {
|
|
|
|
|
print " Si ce depassement est un fonctionnement normal, il faut augmenter la taille admissible dans la variable \$TAILLE_MAX_FIC_REDIR au debut du script de test $NOM_PROG pour rendre possible ce test.\n";
|
|
|
|
|
last BOUCLE_TEST;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#---cas d un probleme de redirection d affichage (sans doute probleme lie a la commande "tee")
|
|
|
|
|
elsif($status_calcul eq "probleme redirection affichage") {
|
|
|
|
|
printRapport(" -> ECHEC : il y a eu un probleme dans la redirection de l affichage via la commande \"tee\" (le fichier $fichier_test.log n a pas ete cree). Cause possible : commande tee introuvable\n\n");
|
|
|
|
|
@ -453,6 +458,15 @@ BOUCLE_TEST:for(my $no_test=1; $no_test<=$nb_CVisu; $no_test++) {
|
|
|
|
|
last BOUCLE_TEST;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#---cas d un arret a cause d une activite cpu nulle
|
|
|
|
|
elsif($status_calcul eq "activite cpu nulle") {
|
|
|
|
|
printRapport(" -> ECHEC : le calcul ne s arretait pas alors qu il avait une activite cpu nulle\n");
|
|
|
|
|
printRapport(" La cause possible est un probleme de menu interactif (verifiez le fichier .commande si il existe)\n\n");
|
|
|
|
|
print "**Erreur Test $repertoire_test/.CVisu$no_test : le calcul ne s arretait pas alors qu il avait une activite cpu nulle\n";
|
|
|
|
|
print " La cause possible est un probleme de menu interactif (verifiez le fichier .commande si il existe)\n";
|
|
|
|
|
last BOUCLE_TEST;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#################################################################################
|
|
|
|
|
#cas d une verification via un script dedie (fichier .verif)
|
|
|
|
|
#################################################################################
|
|
|
|
|
@ -818,11 +832,12 @@ sub printRapport {
|
|
|
|
|
# - fichier de commande (reponses en interactif)
|
|
|
|
|
#
|
|
|
|
|
# en sortie :
|
|
|
|
|
# - indicateur sur le status du calcul : "ok" si calcul a termine (converge ou non)
|
|
|
|
|
# "depassement taille maximum" si calcul a conduit a un depassement du maximum autorise pour la taille du fichier de redirection
|
|
|
|
|
# "probleme redirection affichage" si la redirection de l affichage n a pas ete faite correctement (dans ce cas, probleme lie a la commande tee)
|
|
|
|
|
#
|
|
|
|
|
# - indicateur sur le status du calcul : "ok" => calcul a termine normalement (converge ou non)
|
|
|
|
|
# "depassement taille maximum" => calcul a conduit a un depassement du maximum autorise pour la taille du fichier de redirection
|
|
|
|
|
# "probleme redirection affichage" => la redirection de l affichage n a pas ete faite correctement (dans ce cas, probleme lie a la commande tee)
|
|
|
|
|
# "activite cpu nulle" => calcul ne s arretait pas alors qu il avait une activite cpu nulle
|
|
|
|
|
sub lancement_commande {
|
|
|
|
|
use IO::Handle;
|
|
|
|
|
|
|
|
|
|
my $hzchemin_original = shift;
|
|
|
|
|
my $commande = shift;
|
|
|
|
|
@ -844,35 +859,31 @@ sub lancement_commande {
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
##############################################################
|
|
|
|
|
#creation de la commande
|
|
|
|
|
##############################################################
|
|
|
|
|
my $cmd = "$lien_symbolique_HZ $commande";
|
|
|
|
|
#on ajoute des reponses interactives si le fichier $fic_commande existe
|
|
|
|
|
$cmd .= " < $fic_commande" if(-e $fic_commande);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
##############################################################
|
|
|
|
|
#lancement du calcul Herezh dans un processus fils
|
|
|
|
|
#lancement du calcul Herezh dans un pipe
|
|
|
|
|
# rq : redirection de l affichage dans le fichier $fredir_tee
|
|
|
|
|
##############################################################
|
|
|
|
|
my $PID_CALCUL = fork();
|
|
|
|
|
#
|
|
|
|
|
#le bloc suivant ne concerne que le processus fils
|
|
|
|
|
if($PID_CALCUL == 0) {
|
|
|
|
|
#lancement du calcul Herezh
|
|
|
|
|
system("$cmd | tee $fredir_tee");
|
|
|
|
|
exit;
|
|
|
|
|
}
|
|
|
|
|
#pause de 0.5 seconde pour laisser le temps de lancer la commande
|
|
|
|
|
select(undef, undef, undef, 0.5);
|
|
|
|
|
open(PIPE, "|$lien_symbolique_HZ $commande | tee $fredir_tee");
|
|
|
|
|
PIPE->autoflush(1);#forcer a vider le tampon (methode autoflush du package IO::Handle)
|
|
|
|
|
|
|
|
|
|
#ecriture des reponses interactives si le fichier $fic_commande existe
|
|
|
|
|
if(-e $fic_commande) {
|
|
|
|
|
open(FIC, "<$fic_commande");
|
|
|
|
|
while(<FIC>) {
|
|
|
|
|
print PIPE;
|
|
|
|
|
}
|
|
|
|
|
close(FIC);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
##############################################################
|
|
|
|
|
#recuperation des pid de processus Herezh (dans la variable @HZpid)
|
|
|
|
|
# rq : pour pouvoir les tuer en cas de probleme
|
|
|
|
|
##############################################################
|
|
|
|
|
#saisie de la liste des processus sous la forme "pid commande" en ne gardant que les processus comportant la chaine $lien_symbolique_HZ pour l utilisateur courant $ENV{USER}
|
|
|
|
|
my @processus = qx(ps -U $ENV{USER} -o pid,command | grep $lien_symbolique_HZ);
|
|
|
|
|
#saisie de la liste des processus sous la forme "pid %cpu commande" en ne gardant (grep) que les processus comportant la chaine $lien_symbolique_HZ pour l utilisateur courant $ENV{USER}
|
|
|
|
|
# et en ne gardant pas (grep -v) les processus contenant le mot grep
|
|
|
|
|
my @processus = qx(ps -U $ENV{USER} -o pid,%cpu,command | grep $lien_symbolique_HZ | grep -v grep);
|
|
|
|
|
# remarque : idealement, @processus ne contient qu un seul processus (celui du calcul) grace au filtrage grep
|
|
|
|
|
# mais si il en contient plus, ca ne posera pas de probleme car de toute facon, tous les processus contenant le mot $lien_symbolique_HZ
|
|
|
|
|
# peuvent etre tues sans perturber le reste de l activite de la machine
|
|
|
|
|
#on ne garde que le pid des processus et on les stocke dans @HZpid
|
|
|
|
|
my @HZpid = ();
|
|
|
|
|
foreach my $processus (@processus) {
|
|
|
|
|
@ -887,9 +898,7 @@ sub lancement_commande {
|
|
|
|
|
##############################################################
|
|
|
|
|
if(not -e $fredir_tee) {
|
|
|
|
|
#suppression des processus de calcul
|
|
|
|
|
kill("TERM", @HZpid) if(@HZpid ne "");
|
|
|
|
|
#attente de la fin du processus fils de lancement du calcul
|
|
|
|
|
waitpid($PID_CALCUL, 0);
|
|
|
|
|
kill("TERM", @HZpid);
|
|
|
|
|
#suppression lien symbolique
|
|
|
|
|
system("rm -f $lien_symbolique_HZ");
|
|
|
|
|
|
|
|
|
|
@ -897,77 +906,139 @@ sub lancement_commande {
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
##############################################################
|
|
|
|
|
# surveillance en continu de la taille du fichier de redirection dans un processus fils
|
|
|
|
|
##############################################################
|
|
|
|
|
#le fichier $fic_communication permettra d indiquer au processus pere que le fichier $fredir_tee a depasse la taille maximum autorisee $TAILLE_MAX_FIC_REDIR octets
|
|
|
|
|
# et il permet egalement au processus fils de savoir si la surveillance n est plus necessaire
|
|
|
|
|
my $fic_communication = "$lien_symbolique_HZ.communication";
|
|
|
|
|
system("rm -f $fic_communication");
|
|
|
|
|
|
|
|
|
|
my $PID_TAILLE_FIC_REDIR = fork();
|
|
|
|
|
#
|
|
|
|
|
#...maintenant, on va lancer un processus fils pour surveiller le calcul. On provoque son arret force (kill -9) dans les cas suivants :
|
|
|
|
|
# 1) si la taille du fichier $fredir_tee depasse $TAILLE_MAX_FIC_REDIR octets
|
|
|
|
|
# 2) si le calcul a une activite cpu nulle mais ne s arrete pas
|
|
|
|
|
#
|
|
|
|
|
|
|
|
|
|
##############################################################
|
|
|
|
|
# surveillance en continu dans un processus fils :
|
|
|
|
|
# - de la taille du fichier de redirection
|
|
|
|
|
# - de l activite cpu du calcul
|
|
|
|
|
##############################################################
|
|
|
|
|
#la creation du fichier $fic_com_taille_max permettra d indiquer au processus pere que le fichier $fredir_tee a depasse la taille maximum autorisee $TAILLE_MAX_FIC_REDIR octets
|
|
|
|
|
my $fic_com_taille_max = "$lien_symbolique_HZ.TAILLE_MAX_FIC_REDIR"; system("rm -f $fic_com_taille_max");
|
|
|
|
|
#la creation du fichier $fic_com_activite_cpu permettra d indiquer au processus pere que les processus ont une activite nulle
|
|
|
|
|
my $fic_com_activite_cpu = "$lien_symbolique_HZ.ACTIVITE_CPU"; system("rm -f $fic_com_activite_cpu");
|
|
|
|
|
|
|
|
|
|
my $PID_SURVEILLANCE = fork();
|
|
|
|
|
#
|
|
|
|
|
#le bloc suivant ne concerne que le processus fils
|
|
|
|
|
if($PID_TAILLE_FIC_REDIR == 0) {
|
|
|
|
|
while() {
|
|
|
|
|
if($PID_SURVEILLANCE == 0) {
|
|
|
|
|
|
|
|
|
|
#compteur pour reperer si l activite cpu est nulle plusieurs fois d affilee ($nb_fois_cpu_nul_MAX fois)
|
|
|
|
|
my $nb_fois_cpu_nul = 0;
|
|
|
|
|
my $nb_fois_cpu_nul_MAX = 10;
|
|
|
|
|
|
|
|
|
|
LOOP_SURVEILLANCE:while() {
|
|
|
|
|
#pause de 0.5 seconde
|
|
|
|
|
select(undef, undef, undef, 0.5);
|
|
|
|
|
|
|
|
|
|
#taille actuelle du fichier
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
##
|
|
|
|
|
## SURVEILLANCE DE LA TAILLE DU FICHIER
|
|
|
|
|
##
|
|
|
|
|
|
|
|
|
|
#taille actuelle du fichier de redirection
|
|
|
|
|
my $taille_fichier = -s $fredir_tee;
|
|
|
|
|
|
|
|
|
|
#si la taille du fichier a depasse la limite => on cree le fichier de communication, on tue les processus de calcul et on sort de la boucle
|
|
|
|
|
|
|
|
|
|
#si la taille du fichier a depasse la limite => on cree le fichier de communication $fic_com_taille_max, on tue les processus de calcul et on sort de la boucle
|
|
|
|
|
if($taille_fichier > $TAILLE_MAX_FIC_REDIR) {
|
|
|
|
|
system("echo 1 > $fic_communication");
|
|
|
|
|
kill("TERM", @HZpid) if($#HZpid > -1);
|
|
|
|
|
open(FCOM, ">$fic_com_taille_max");
|
|
|
|
|
close(FCOM);
|
|
|
|
|
kill("TERM", @HZpid);
|
|
|
|
|
last;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
##
|
|
|
|
|
## SURVEILLANCE DE L ACTIVITE CPU
|
|
|
|
|
##
|
|
|
|
|
|
|
|
|
|
#liste des processus sous le format "%cpu commande" dont la commande contient le mot $lien_symbolique_HZ et pas le mot grep
|
|
|
|
|
my @process = qx(ps -U $ENV{USER} -o %cpu,command | grep $lien_symbolique_HZ | grep -v grep);
|
|
|
|
|
|
|
|
|
|
#on sort de la boucle si aucun processus ne tourne
|
|
|
|
|
last if($#process == -1);
|
|
|
|
|
|
|
|
|
|
#liste des activites cpu
|
|
|
|
|
my @activite_cpu = ();
|
|
|
|
|
foreach my $process (@process) {
|
|
|
|
|
next if(not $process =~ /^\s*\d/);
|
|
|
|
|
$process =~ s/^\s+//;#suppression espaces en debut
|
|
|
|
|
($process) = split(/\s+/, $process);#separation suivant les espaces et on ne garde que le premier element retourne par split
|
|
|
|
|
$process =~ s/,/./;#remplacement d une eventuelle virgule par un . dans le nombre reel representant l activite cpu
|
|
|
|
|
push(@activite_cpu, $process);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#si l un des processus a une activite non nulle, on en deduit que le calcul tourne encore => on remet a 0 le compteur $nb_fois_cpu_nul et on recommence la boucle
|
|
|
|
|
foreach my $activite_cpu (@activite_cpu) {
|
|
|
|
|
if($activite_cpu > 0) {
|
|
|
|
|
$nb_fois_cpu_nul = 0;
|
|
|
|
|
next LOOP_SURVEILLANCE;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#sinon, on est dans le cas ou l activite cpu est nulle => on incremente le compteur
|
|
|
|
|
$nb_fois_cpu_nul++;
|
|
|
|
|
|
|
|
|
|
#si le compteur est egal au max, on kill les processus, on cree le fichier de communication $fic_com_activite_cpu et on sort de la boucle
|
|
|
|
|
if($nb_fois_cpu_nul == $nb_fois_cpu_nul_MAX) {
|
|
|
|
|
open(FCOM, ">$fic_com_activite_cpu");
|
|
|
|
|
close(FCOM);
|
|
|
|
|
kill('TERM', @HZpid);
|
|
|
|
|
last;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#on arrete cette boucle si le fichier $fic_communication a ete cree par le processus pere
|
|
|
|
|
# rq : si c est le cas, cela veut dire que le processus fils $PID_CALCUL s est arrete normalement
|
|
|
|
|
# et que donc la surveillance n est plus necessaire
|
|
|
|
|
last if(-e $fic_communication);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
exit;
|
|
|
|
|
}
|
|
|
|
|
}#fin du fils
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
##############################################################
|
|
|
|
|
#attente de la fin du processus fils du lancement du calcul
|
|
|
|
|
#fermeture du pipe
|
|
|
|
|
##############################################################
|
|
|
|
|
waitpid($PID_CALCUL, 0);
|
|
|
|
|
close(PIPE);
|
|
|
|
|
|
|
|
|
|
#suppression du lien symbolique qui ne sert plus desormais
|
|
|
|
|
#attente de la fin du processus fils de surveillance
|
|
|
|
|
waitpid($PID_SURVEILLANCE, 0);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
##############################################################
|
|
|
|
|
# etat du calcul
|
|
|
|
|
##############################################################
|
|
|
|
|
|
|
|
|
|
my $status_calcul;
|
|
|
|
|
|
|
|
|
|
#si le fichier $fic_com_taille_max existe, cela veut dire qu il y a eu un depassement de la taille maximum autorisee
|
|
|
|
|
# => status => depassement taille maximum
|
|
|
|
|
if(-e $fic_com_taille_max) {
|
|
|
|
|
$status_calcul = 'depassement taille maximum';
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#si le fichier $fic_com_activite_cpu existe, cela veut dire qu il y a eu un arret a cause d un calcul qui attend sans activite
|
|
|
|
|
# => status => activite cpu nulle
|
|
|
|
|
elsif(-e $fic_com_activite_cpu) {
|
|
|
|
|
$status_calcul = 'activite cpu nulle';
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#sinon ca veut dire que le calcul Herezh s est arrete normalement (qu il ait converge ou non)
|
|
|
|
|
# => status calcul = ok
|
|
|
|
|
else {
|
|
|
|
|
$status_calcul = 'ok';
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
#suppression des eventuels fichiers de communication
|
|
|
|
|
system("rm -f $fic_com_taille_max $fic_com_activite_cpu");
|
|
|
|
|
#suppression du lien symbolique
|
|
|
|
|
system("rm -f $lien_symbolique_HZ");
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
##############################################################
|
|
|
|
|
# verification de l etat du calcul
|
|
|
|
|
##############################################################
|
|
|
|
|
|
|
|
|
|
#si le fichier $fic_communication existe, cela veut dire qu il a ete cree par le processus fils $PID_TAILLE_FIC_REDIR et que donc il y a eu un depassement de la taille maximum autorisee
|
|
|
|
|
# => status calcul = depassement taille maximum
|
|
|
|
|
if(-e $fic_communication) {
|
|
|
|
|
#on s assure que le processus fils de surveillance s est termine proprement
|
|
|
|
|
waitpid($PID_TAILLE_FIC_REDIR, 0);
|
|
|
|
|
#suppression du fichier de communication
|
|
|
|
|
system("rm -f $fic_communication");
|
|
|
|
|
|
|
|
|
|
return "depassement taille maximum";
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#si le fichier $fic_communication n existe pas, alors ca veut dire que le calcul Herezh s est arrete normalement (qu il ait converge ou non)
|
|
|
|
|
# => status calcul = ok
|
|
|
|
|
else {
|
|
|
|
|
#on envoie un signal au processus fils $PID_TAILLE_FIC_REDIR
|
|
|
|
|
system("echo 1 > $fic_communication");
|
|
|
|
|
#on attend la fin du processus fils $PID_TAILLE_FIC_REDIR
|
|
|
|
|
waitpid($PID_TAILLE_FIC_REDIR, 0);
|
|
|
|
|
#on supprime le fichier de communication
|
|
|
|
|
system("rm -f $fic_communication");
|
|
|
|
|
|
|
|
|
|
return 'ok';
|
|
|
|
|
}
|
|
|
|
|
return $status_calcul;
|
|
|
|
|
|
|
|
|
|
}#sub lancement_commande
|
|
|
|
|
|
|
|
|
|
|
troufflard