API tools faq
paste
Guest User

Untitled

a guest
May 25th, 2018
60
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 26.58 KB | None | 0 0
raw download clone embed print report
  1.  
  2. sub Sub_TriEnUnFichier {
  3. local($DateCourante,$FichierTraitement,$Service) = @_;
  4. $[ = 1; # set array base to 1
  5. $, = ' '; # set output field separator
  6. $\ = "\n"; # set output record separator
  7.  
  8. $FichierCourant = 'TriEnUnFichier';
  9. &Fct_Conf($FichierCourant);
  10. $FichierListeService = $Tab{'FichierListeService'};
  11. $RepertoireEntree = $Tab{'RepertoireEntree'};
  12. $RepertoireSortie = $Tab{'RepertoireSortie'};
  13. $RepertoireConf = $Tab{'RepertoireConf'};
  14. $RepertoireProcessus = $Tab{'RepertoireProcessus'};
  15. $NbreProcess = $Const{'NbreProcess'};
  16. $MAXNBLIGNES = $Const{'MaxNbLignes'};
  17. $LIMITEBOUCLE = $Const{'LimiteBoucle'};
  18.  
  19. ####################################################################################################
  20. # Recuperation des parametres passes lors de l'appel
  21. ####################################################################################################
  22. # Definition de la date et du service a prendre en compte
  23. &Fct_DefinitionProfil($FichierListeService, $RepertoireEntree,$Service);
  24. open(FICHIER1,$FichierListeService) || die "Fichier $FichierListeService non trouvé";
  25. my @lignesFichierListeService = <FICHIER1>;
  26. close(FICHIER1);
  27. unlink($FichierListeService) if -f $FichierListeService;
  28. print "################################################################################################";
  29. print "# Concatenation des logs et tri du fichier resultant du ".$DateCourante;
  30. print "################################################################################################";
  31. print STDOUT "################################################################################################";
  32. print STDOUT "# Concatenation des logs et tri du fichier resultant du ".$DateCourante;
  33. print STDOUT "################################################################################################";
  34.  
  35. ####################################################################################################
  36. # Boucle de gestion des Profils a traiter
  37. ####################################################################################################
  38. my $i = 0;
  39. foreach $domain (@lignesFichierListeService) {
  40. $i++;
  41. $domain =~ s/\n//g;
  42. if( $i == $NbreProcess){
  43. do {
  44. $i = `ls $RepertoireProcessus |wc -l`;
  45. $i =~ s/\n//g;
  46. } until $i < $NbreProcess;
  47. }
  48. if ($pid = fork) {
  49. push @pid, $pid;
  50. }else{
  51. if($domain){
  52. print STDOUT "Traitement du service : ".$domain;
  53. $FichierPID = $RepertoireProcessus."Fichier_Compteur_pid_".$$.".tmp";
  54. `echo "Fichier process $$" > $FichierPID`;
  55. &Fct_TriEnUnFichier($domain,$DateCourante,$$);
  56. if (-f $FichierPID) { `rm -f $FichierPID`; }
  57. }
  58. exit;
  59. }
  60. }
  61. map {waitpid($_, 0)} (@pid);
  62. undef @pid;
  63. }
  64.  
  65. sub Fct_TriEnUnFichier {
  66. local($domain,$DateCouranteEntree,$Pid) = @_;
  67. $FichierCourant = 'TriEnUnFichier';
  68. &Fct_Conf($FichierCourant);
  69. $LIMITEBOUCLE = $Const{'LimiteBoucle'};
  70. $Annee = $Const{'Annee'};
  71. &Fct_DefinitionDate(*Date, $DateCouranteEntree);
  72. $DateCouranteInversee = $Date{$Annee}.'-'.$Date{$Mois}.'-' .$Date{$Jour};
  73. $DateCourante = $Date{$Jour}.'-'.$Date{$Mois}.'-'.$Date{$Annee};
  74. $RepertoireScripts = $Tab{'RepertoireScripts'};
  75. $RepertoireLogs = $Tab{'RepertoireLogs'};
  76. $RepertoireEntree = $Tab{'RepertoireEntree'};
  77. $RepertoireTraitement = $Tab{'RepertoireTraitement'};
  78. #---------------------------------------------------------------
  79. # Affichage en tete du traitement pour DOMAIN
  80. #---------------------------------------------------------------
  81. $date_debut_tri = `date "+%a %Y/%m/%d %H:%M:%S"`;
  82. $date_debut_tri =~ s/\n//g;
  83. #---------------------------------------------------------------
  84. # Init des variables
  85. #---------------------------------------------------------------
  86. # Creation du repertoire correspondant au service dans le repertoire de sortie
  87. $RepSortie = $RepertoireSortie.$domain;
  88. `mkdir $RepSortie` if !(-d $RepSortie);
  89. # Fichier resultat : logs apache de la journee tries par ordre chronologique
  90. $FichierFinal = $RepertoireSortie.$domain.'/'.$domain.'.'.$DateCouranteInversee.'.log';
  91. `rm -f $FichierFinal` if -f $FichierFinal;
  92. $FichierFinalgz = $RepertoireSortie.$domain.'/'.$domain.'.'.$DateCouranteInversee.'.log.gz';
  93. `rm -f $FichierFinalgz` if -f $FichierFinalgz;
  94. # Repertoire ou se situent tous les logs apache en entree
  95. $RepertoireService = $RepertoireEntree.$domain;
  96. # Recupere la liste des fichiers contenant les logs apache de la journee DateCourante
  97. $MaxNbFichiers = `/bin/ls -1 $RepertoireService/*$DateCourante* |wc -l`;
  98. $MaxNbFichiers =~ s/\n//g;
  99. #---------------------------------------------------------------
  100. # Traitement des logs en fonction du cas
  101. #---------------------------------------------------------------
  102. # Affiche l'action qui est entrain d'etre realisee dans les logs
  103. if ($MaxNbFichiers > 0) {
  104. # Il existe au moins un fichier de logs pour la journee DateCourante
  105. if ($MaxNbFichiers == 1) {
  106. # Il existe un seul fichier de logs donc on ne fait qu'une copie car le fichier est deja trie
  107. `cp -f $RepertoireService/*$DateCourante* $FichierFinalgz`;
  108. }else{
  109. #---------------------------------------------------------------
  110. # Initialise les variables
  111. #---------------------------------------------------------------
  112. # Efface et recree le repertoire temporaire /LogsTemporaire
  113. $RepertoireFichiersTemporaire = $RepertoireTraitement.'RepertoireFichiersTemporaire_'.$Pid;
  114. `rm -r $RepertoireFichiersTemporaire` if (-d $RepertoireFichiersTemporaire);
  115. `mkdir $RepertoireFichiersTemporaire` if !(-d $RepertoireFichiersTemporaire);
  116. # Efface et recree le repertoire temporaire /LogsTemporaire
  117. $RepertoireLogTemporaire = $RepertoireTraitement.'LogsTemporaire_'.$Pid;
  118. `rm -r $RepertoireLogTemporaire` if (-d $RepertoireLogTemporaire);
  119. `mkdir $RepertoireLogTemporaire` if !(-d $RepertoireLogTemporaire);
  120. # Efface et recree le repertoire oy se situe les fichiers resultats
  121. $FichiersTempo = $RepertoireTraitement.'FichiersTempo_'.$Pid;
  122. `rm -r $FichiersTempo` if (-d $FichiersTempo);
  123. `mkdir $FichiersTempo` if !(-d $FichiersTempo);
  124. # Efface tous les fichiers zippes ou non ayant le nom du fichier resultat
  125. $FichierPouilleme = $RepertoireFichiersTemporaire.'/FichierPouilleme_'.$Pid.'.tmp';
  126. `rm -f $FichierPouilleme` if -f $FichierPouilleme;
  127. $FichierPouillemeTmp = $RepertoireFichiersTemporaire.'/FichierPouillemeTmp_'.$Pid.'.tmp';
  128. `rm -f $FichierPouillemeTmp` if -f $FichierPouillemeTmp;
  129. $FichierListeTemporaire = $RepertoireFichiersTemporaire.'/FichierListeTemporaire_'.$Pid.'.tmp';
  130. `rm -f $FichierListeTemporaire` if -f $FichierListeTemporaire;
  131. # Copie tous les fichiers dans le repertoire temporaire
  132. #`cp $RepertoireService/*$DateCourante* $RepertoireLogTemporaire`;
  133. $NbFichiersATransferer = `/bin/ls -1 $RepertoireService/*$DateCourante* |wc -l`;
  134. while($NbFichiersATransferer > 0)
  135. {
  136. $NomFichierATransferer = `/bin/ls -1 $RepertoireService/*$DateCourante* | tail -1`;
  137. $NomFichierATransferer =~ s/\n//g;
  138. $Cmd = "wc -l $NomFichierATransferer | awk '{split(\$0,res,\" \");print res[1];}'";
  139. $NbLignesFichierATransferer = `$Cmd`;
  140. $RepertoireServiceArchive = "$RepertoireService/ARCHIVE";
  141. `mkdir -p $RepertoireServiceArchive` if !(-d $RepertoireServiceArchive);
  142. if($NbLignesFichierATransferer == 0)
  143. {
  144. `mv $NomFichierATransferer $RepertoireServiceArchive`;
  145. }else{
  146. `cp $NomFichierATransferer $RepertoireLogTemporaire`;
  147. `mv $NomFichierATransferer $RepertoireServiceArchive`;
  148. }
  149. $NbFichiersATransferer = `/bin/ls -1 $RepertoireService/*$DateCourante* |wc -l`;
  150. }
  151. $date_debut_gunzip = `date "+%a %Y/%m/%d %H:%M:%S"`;
  152. $date_debut_gunzip =~ s/\n//g;
  153. @TabFichiersGunzip = `ls -1 $RepertoireLogTemporaire/*`;
  154. foreach $fichierAGunzip (@TabFichiersGunzip){
  155. `gunzip $fichierAGunzip`;
  156. }
  157. $NbFichiersATraiter = `ls $RepertoireLogTemporaire | wc -l`;
  158. $NbFichiersATraiter =~ s/\n//g;
  159. #---------------------------------------------------------------
  160. # Traitement du cas ou il y a plus de LIMITEBOUCLE fichiers
  161. #---------------------------------------------------------------
  162. if ($NbFichiersATraiter >= $LIMITEBOUCLE) {
  163. $date_traitement_2par2 = `date "+%a %Y/%m/%d %H:%M:%S"`;
  164. $date_traitement_2par2 =~ s/\n//g;
  165. &Fct_TraiementLIMITEBOUCLEfichiers($Pid,$NbFichiersATraiter,$LIMITEBOUCLE,$RepertoireFichiersTemporaire,$domain,*TabDomainIIS,$FichiersTempo,$DateCourante,$FichierPouilleme,$RepertoireLogTemporaire);
  166. }
  167. #---------------------------------------------------------------
  168. # Traitement en parallele des fichiers restants
  169. #---------------------------------------------------------------
  170. $date_traitement_parallele = `date "+%a %Y/%m/%d %H:%M:%S"`;
  171. $date_traitement_parallele =~ s/\n//g;
  172. &Fct_ConcatenationTrie("1",$Pid,$RepertoireFichiersTemporaire,$domain,*TabDomainIIS,$FichiersTempo,$DateCourante,$FichierPouilleme,$RepertoireLogTemporaire);
  173. #---------------------------------------------------------------
  174. # Traitement final du fichier trie concantene
  175. #---------------------------------------------------------------
  176. $NombreFichiersResultat = `ls $RepertoireFichiersTemporaire | wc -l`;
  177. #print STDOUT "ls $RepertoireFichiersTemporaire | wc -l";
  178. if ($NombreFichiersResultat == 1) {
  179. $NomFichierTemp = `ls -1 $RepertoireFichiersTemporaire`;
  180. $NomFichierTemp =~ s/\n//g;
  181. $FichFinal = $RepertoireFichiersTemporaire.'/'.$NomFichierTemp;
  182. }else{
  183. $FichFinal = $RepertoireFichiersTemporaire.'/FichFinal.tmp';
  184. }
  185. $date_debut_gzip = `date "+%a %Y/%m/%d %H:%M:%S"`;
  186. $date_debut_gzip =~ s/\n//g;
  187. `mv $FichFinal $FichierFinal`;
  188. system('gzip -1f '.$FichierFinal) if (-f $FichierFinal);
  189. $Nb_fichiers_RecuperationDeLaVeille = `ls $RepertoireEntree$domain/RecuperationDeLaVeille*.log | wc -l`;
  190. #print STDOUT "ls $RepertoireEntree$domain/RecuperationDeLaVeille*.log | wc -l";
  191. system('gzip -1f '.$RepertoireEntree.$domain.'/RecuperationDeLaVeille*.log') if ($Nb_fichiers_RecuperationDeLaVeille>0);
  192. `rm -r $RepertoireLogTemporaire` if (-d $RepertoireLogTemporaire);
  193. `rm -r $FichiersTempo` if (-d $FichiersTempo);
  194. `rm -r $RepertoireFichiersTemporaire` if (-d $RepertoireFichiersTemporaire);
  195. }
  196. }
  197. #---------------------------------------------------------------
  198. # Affichage fin du traitement pour DOMAIN
  199. #---------------------------------------------------------------
  200. select(FICHIER);
  201. print '';
  202. print '#####################################################################';
  203. print '# Traitement du service ' . $domain . ';';
  204. print '#####################################################################';
  205. print '';
  206. print $domain.' => Debut du traitement a : '.$date_debut_tri;
  207. print $domain.' => Concatenation des differents fichiers ';
  208. print $domain.' => Le fichier final est : '.$FichierFinal;
  209. if ($MaxNbFichiers == 0) {
  210. # Aucun fichier de logs pour la journee DateCourante donc rien a faire
  211. print $domain.' => Il n\'y a aucun fichier en entree';
  212. }else{
  213. # Il existe au moins un fichier de logs pour la journee DateCourante
  214. if ($MaxNbFichiers == 1) {
  215. # Il existe un seul fichier de logs donc on ne fait qu'une copie car le fichier est deja trie
  216. print $domain.' => Il y a un seul fichier en entree';
  217. }else{
  218. print $domain.' => Debut de gunzip de tous les fichiers a : '.$date_debut_gunzip;
  219. if ($NbFichiersATraiter > $LIMITEBOUCLE) {
  220. print $domain.' => Debut traitement 2 par 2 des '.$NbFichiersATraiter.' fichiers (LIMITEBOUCLE='.$LIMITEBOUCLE.') a : '.$date_traitement_2par2;
  221. }
  222. print $domain.' => Debut ConcatenationTrie a : '.$date_traitement_parallele;
  223. print $domain.' => Debut du gzip du fichier final a : '.$date_debut_gzip;
  224. }
  225. }
  226. $date_fin_tri = `date "+%a %Y/%m/%d %H:%M:%S"`;
  227. $date_fin_tri =~ s/\n//g;
  228. print $domain.' => Fin du traitement a : '.$date_fin_tri;
  229. $_ = $date_debut_tri;
  230. if(/(....)\/(..)\/(..).(..):(..):(..)$/) {$JourDebut=$3;$TempsDebut=$4*3600+$5*60+$6;}
  231. $_ = $date_fin_tri;
  232. if(/(....)\/(..)\/(..).(..):(..):(..)$/) {$JourFin=$3;$TempsFin=$4*3600+$5*60+$6;}
  233. $JourDiff=$JourFin-$JourDebut;
  234. if($JourDiff == 0){ $TempsDiff=$TempsFin-$TempsDebut; }else{ $TempsDiff=$TempsFin-$TempsDebut+24*3600; }
  235. $HeureDiff = int($TempsDiff / 3600);
  236. $MinuteDiff = int(($TempsDiff - $HeureDiff * 3600) / 60);
  237. $SecondeDiff = $TempsDiff - $HeureDiff * 3600 - $MinuteDiff * 60;
  238. print $domain.' => Temps de traitement = '.$HeureDiff.':'.$MinuteDiff.':'.$SecondeDiff;
  239. }
  240.  
  241. sub Fct_TraiementLIMITEBOUCLEfichiers {
  242. local($Pid,$NbFichiersATraiter,$LIMITEBOUCLE,$RepertoireFichiersTemporaire,$domain,*TabDomainIIS,$FichiersTempo,$DateCourante,$FichierPouilleme,$RepertoireLogTemporaire) = @_;
  243. #---------------------------------------------------------------
  244. # Traitement du cas ou il y a plus de LIMITEBOUCLE fichiers
  245. #---------------------------------------------------------------
  246. # Limiter le nombre de fichiers a LUMITEBOUCLE avant de les concatener en parallele
  247. while ($NbFichiersATraiter >= $LIMITEBOUCLE) {
  248. # Permet d'avoir les deux fichiers de plus petite taille
  249. @DeuxFichiers = `ls -S1 $RepertoireLogTemporaire | tail -2`;
  250. $DeuxFichiers[1] =~ s/\n//g;
  251. $DeuxFichiers[2] =~ s/\n//g;
  252. $FichierGlobal1 = $RepertoireLogTemporaire.'/'.$DeuxFichiers[1];
  253. $FichierGlobal2 = $RepertoireLogTemporaire.'/'.$DeuxFichiers[2];
  254. # Calcule le nbre de lignes des deux fichiers
  255. $NbreLignesFich1 = 0;
  256. if( -f $FichierGlobal1 ){ $NbreLignesFich1 = `wc -l $FichierGlobal1 | awk '{print \$1}'`; $NbreLignesFich1 =~ s/\n//g; }
  257. $NbreLignesFich2 = 0;
  258. if( -f $FichierGlobal2 ){ $NbreLignesFich2 = `wc -l $FichierGlobal2 | awk '{print \$1}'`; $NbreLignesFich2 =~ s/\n//g; }
  259. if ($NbreLignesFich1 == 0 && $NbreLignesFich2 == 0) {
  260. # On supprime les deux fichiers
  261. if (-f $FichierGlobal1) { `rm -f $FichierGlobal1`; }
  262. if (-f $FichierGlobal2) { `rm -f $FichierGlobal2`; }
  263. }else{
  264. if ($NbreLignesFich1 > 0 && $NbreLignesFich2 == 0) {
  265. # La concatenation est egal au premier fichier
  266. if (-f $FichierGlobal2) { `rm -f $FichierGlobal2`; }
  267. }else{
  268. if ($NbreLignesFich1 == 0 && $NbreLignesFich2 > 0) {
  269. # La concatenation est egal au deuxieme fichier
  270. if (-f $FichierGlobal1) { `rm -f $FichierGlobal1`; }
  271. }else{
  272. # Les fichiers ont des données, on les concatene
  273. &Fct_ConcatenationTrie("2",$Pid,$RepertoireFichiersTemporaire,$domain,*TabDomainIIS,$FichiersTempo,$DateCourante,$FichierPouilleme,$RepertoireLogTemporaire);
  274. if (-f $FichierGlobal1) { `rm -f $FichierGlobal1`; }
  275. if (-f $FichierGlobal2) { `rm -f $FichierGlobal2`; }
  276. }
  277. }
  278. }
  279. $NbFichiersATraiter = `ls $RepertoireLogTemporaire | wc -l`;
  280. $NbFichiersATraiter =~ s/\n//g;
  281. }
  282. }
  283.  
  284. sub Fct_ConcatenationTrie {
  285. local($Cas,$Pid,$RepertoireFichiersTemporaire,$domain,*TabDomainIIS,$FichiersTempo,$DateCourante,$FichierPouilleme,$RepertoireLogTemporaire) = @_;
  286. # Nombre de fichiers ayant un contenu
  287. # CAS DU TRAITEMETN DE TOUS LES FICHIERS DU REPERTOIRE
  288. $FichierTmpListeFichiers = $RepertoireFichiersTemporaire.'/FichierTmpListeFichiers'.$Pid.'.tmp';
  289. if($Cas == 1) {
  290. $MaxNbFichiers = `ls $RepertoireLogTemporaire | wc -l`;
  291. $MaxNbFichiers =~ s/\n//g;
  292. $CmdListeFichiers = 'ls -Sr1 '.$RepertoireLogTemporaire.'/* > '.$FichierTmpListeFichiers;
  293. $FichTemp = $RepertoireFichiersTemporaire.'/FichFinal.tmp';
  294. }
  295. # CAS DU TRAITEMENT 2 FICHIERS PAR 2 FICHIERS
  296. if($Cas == 2) {
  297. $MaxNbFichiers = 2;
  298. $CmdListeFichiers = 'ls -S1 '.$RepertoireLogTemporaire.'/* | tail -'.$MaxNbFichiers.' > '.$FichierTmpListeFichiers;
  299. $NbFichConcatene = `ls $RepertoireLogTemporaire | wc -l`;
  300. $NbFichConcatene =~ s/\n//g;
  301. $FichTemp = $RepertoireLogTemporaire.'/FichConcatene'.$NbFichConcatene.'.tmp';
  302. }
  303. $MaxNbFichiers =~ s/\n//g;
  304. # Traitement des logs en fonction du cas
  305. if($MaxNbFichiers == 0) {
  306. # Aucun fichier de logs pour la journee DateCourante donc rien a faire
  307. $DateTemp = `date`;
  308. $DateTemp =~ s/\n//g;
  309. }else{
  310. # Il existe au moins un fichier de logs pour la journee DateCourante
  311. if($MaxNbFichiers == 1) {
  312. # Il existe un seul fichier de logs donc on ne fait qu'une copie car le fichier est deja trie
  313. $DateTemp = `date`;
  314. $DateTemp =~ s/\n//g;
  315. $FichTemp = $RepertoireFichiersTemporaire.'/FichFinal.tmp';
  316. `cat $RepertoireLogTemporaire/* > $FichTemp`;
  317. }else{
  318. # Il y a plus d'un fichier de logs donc concatenation des differents fichiers
  319. # Initialisation du tableau @TabFichComplet contenant l'ensemble des fichiers
  320. `$CmdListeFichiers`;
  321. open(FICHIERRLT,$FichierTmpListeFichiers) || die "Fichier $FichierTmpListeFichiers non trouvé";
  322. my @ListeFichAConcatener = <FICHIERRLT>;
  323. close(FICHIERRLT);
  324. if (-f $FichierTmpListeFichiers) { `rm -f $FichierTmpListeFichiers`; }
  325. my $NumeroFichier = 0;
  326. my $ligne = "";
  327. for($indice = 0 ; $indice < $LIMITEBOUCLE ; $indice++){
  328. $F[$indice] = "Ferme";
  329. }
  330. foreach $FichAConcatener (@ListeFichAConcatener){
  331. $FichAConcatener =~ s/\n//g;
  332. $NbLignesFichAConcatener = `wc -l $FichAConcatener | awk '{print \$1}'`;
  333. $NbLignesFichAConcatener =~ s/\n//g;
  334. $TabFichComplet_env{$NumeroFichier} = [ 0 , $NbLignesFichAConcatener , $FichAConcatener];
  335. if($NumeroFichier == 0 ) { open(FILE0,$FichAConcatener) || die "Fichier $FichAConcatener non trouvé"; }
  336. if($NumeroFichier == 1 ) { open(FILE1,$FichAConcatener) || die "Fichier $FichAConcatener non trouvé"; }
  337. if($NumeroFichier == 2 ) { open(FILE2,$FichAConcatener) || die "Fichier $FichAConcatener non trouvé"; }
  338. if($NumeroFichier == 3 ) { open(FILE3,$FichAConcatener) || die "Fichier $FichAConcatener non trouvé"; }
  339. if($NumeroFichier == 4 ) { open(FILE4,$FichAConcatener) || die "Fichier $FichAConcatener non trouvé"; }
  340. if($NumeroFichier == 5 ) { open(FILE5,$FichAConcatener) || die "Fichier $FichAConcatener non trouvé"; }
  341. if($NumeroFichier == 6 ) { open(FILE6,$FichAConcatener) || die "Fichier $FichAConcatener non trouvé"; }
  342. if($NumeroFichier == 7 ) { open(FILE7,$FichAConcatener) || die "Fichier $FichAConcatener non trouvé"; }
  343. if($NumeroFichier == 8 ) { open(FILE8,$FichAConcatener) || die "Fichier $FichAConcatener non trouvé"; }
  344. if($NumeroFichier == 9 ) { open(FILE9,$FichAConcatener) || die "Fichier $FichAConcatener non trouvé"; }
  345. $F[$NumeroFichier] = "Ouvert";
  346. $NumeroFichier++;
  347. }
  348. # Boucle du traitement
  349. `touch $FichTemp`;
  350. open(FICHIERCOURANT,">>$FichTemp") || die "Fichier $FichTemp non trouvé";
  351. select(FICHIERCOURANT);
  352. $Premiere_Initialisation = 0;
  353. $Boucle = 1;
  354. $ligne = "";
  355. $dateinit = `date +%Y%m%d%H%M%S`;
  356. $dateinit =~ s/\n//g;
  357. while ($Boucle == 1) {
  358. if($Premiere_Initialisation == 0){
  359. for($indice = 0 ; $indice < $NumeroFichier ; $indice++) {
  360. $TabFichComplet_valeurs{$indice} = [ "" , $dateinit ];
  361. $ligne = "";
  362. if($indice == 0) { $ligne = <FILE0>; }
  363. if($indice == 1) { $ligne = <FILE1>; }
  364. if($indice == 2) { $ligne = <FILE2>; }
  365. if($indice == 3) { $ligne = <FILE3>; }
  366. if($indice == 4) { $ligne = <FILE4>; }
  367. if($indice == 5) { $ligne = <FILE5>; }
  368. if($indice == 6) { $ligne = <FILE6>; }
  369. if($indice == 7) { $ligne = <FILE7>; }
  370. if($indice == 8) { $ligne = <FILE8>; }
  371. if($indice == 9) { $ligne = <FILE9>; }
  372. if(!$ligne) { $ligne = ""; }else{ $ligne =~ s/\n//g; }
  373. $dateligne = &Fct_RecupererDate($ligne,*TabDomainIIS,$domain);
  374. if($dateligne != 10000100100100100100) { $TabFichComplet_valeurs{$indice} = [ $ligne , $dateligne ]; }
  375. }
  376. $DateMin = $TabFichComplet_valeurs{0}[2];
  377. $LigneMin = $TabFichComplet_valeurs{0}[1];
  378. $IndiceMin = 0;
  379. $Premiere_Initialisation = 1;
  380. }
  381.  
  382. # Prise en compte de tous les fichiers logs Apache
  383. for ($i = 0; $i < $NumeroFichier; $i++) {
  384. # Si la date de la ligne du fichier i est anterieure a celle de DateMin alors on change toutes les variables xxxMin
  385. # Cette action se fait si le fichier n'est pas celui qui est deja pris par defaut
  386. if ($i != $IndiceMin && $DateMin > $TabFichComplet_valeurs{$i}[2]) {
  387. $DateMin = $TabFichComplet_valeurs{$i}[2];
  388. $LigneMin = $TabFichComplet_valeurs{$i}[1];
  389. $IndiceMin = $i;
  390. }
  391. # Si l'on a atteint le dernier fichier et que l'on a donc compare toutes les lignes des differents curseurs
  392. if ($i == ($MaxNbFichiers - 1)) {
  393. # Impression de la ligne Min dans le fichier final
  394. $_ = $DateMin;
  395. if(/^(....)(..)(..)......$/) {
  396. $datecourtedefinitive = $3.'-'.$2.'-'.$1;
  397. if ($datecourtedefinitive eq $DateCourante) {
  398. if($LigneMin) { print FICHIERCOURANT $LigneMin; }
  399. }else{
  400. #$FichierPouillemeTmp = $RepertoireFichiersTemporaire.'/FichierPouillemeTmp.tmp';
  401. #$FichierListeTemporaire = $RepertoireFichiersTemporaire.'/FichierListeTemporaire.tmp';
  402. #$FichierNomFichierPouilleme = $RepertoireConf.'/NomFichierPouilleme.txt';
  403. #`echo "RecuperationDeLaVeille*$datecourtedefinitive.log.gz" > $FichierNomFichierPouilleme`;
  404. #`echo "RecuperationDeLaVeille*$datecourtedefinitive.log" > $FichierPouillemeTmp`;
  405. #`sort -u $FichierPouillemeTmp > $FichierPouilleme`;
  406. $FichierDuLendemain = $RepertoireEntree.$domain.'/RecuperationDeLaVeille'.$domain.'.'.$datecourtedefinitive.'.log';
  407. $LigneAEcrire = $LigneMin; $LigneAEcrire =~ s/\"/\\\"/g;
  408. if($LigneAEcrire){
  409. if(-f $FichierDuLendemain ){
  410. open(FICHIERDULENDEMAIN,">>$FichierDuLendemain") || die "Fichier $FichierDuLendemain non trouvé";
  411. print FICHIERDULENDEMAIN $LigneAEcrire;
  412. close(FICHIERDULENDEMAIN);
  413. }else{
  414. open(FICHIERDULENDEMAIN,">$FichierDuLendemain") || die "Fichier $FichierDuLendemain non trouvé";
  415. print FICHIERDULENDEMAIN $LigneAEcrire;
  416. close(FICHIERDULENDEMAIN);
  417. }
  418. # `echo "$LigneAEcrire" >> $FichierDuLendemain`; }else{ `echo "$LigneAEcrire" > $FichierDuLendemain`; }
  419. }
  420. }
  421. }
  422.  
  423. # Changement du curseur dans le fichier Min
  424. # Si numero de ligne courante inferieur ou egal au nombre maximum de lignes du fichier
  425. if($TabFichComplet_env{$IndiceMin}[1]<=$TabFichComplet_env{$IndiceMin}[2]){
  426. $TabFichComplet_env{$IndiceMin}[1]++;
  427. # Deux cas :
  428. # la ligne lue est une ligne du fichier donc on change les variables Min
  429. # OU la ligne lue est la derniere ligne du fichier (ligne vide) et donc le fichier ne doit plus etre pris en compte dans les comparaison
  430. if($TabFichComplet_env{$IndiceMin}[1]<=$TabFichComplet_env{$IndiceMin}[2]){
  431. $ligne = "";
  432. if($IndiceMin == 0) { $ligne = <FILE0>; }
  433. if($IndiceMin == 1) { $ligne = <FILE1>; }
  434. if($IndiceMin == 2) { $ligne = <FILE2>; }
  435. if($IndiceMin == 3) { $ligne = <FILE3>; }
  436. if($IndiceMin == 4) { $ligne = <FILE4>; }
  437. if($IndiceMin == 5) { $ligne = <FILE5>; }
  438. if($IndiceMin == 6) { $ligne = <FILE6>; }
  439. if($IndiceMin == 7) { $ligne = <FILE7>; }
  440. if($IndiceMin == 8) { $ligne = <FILE8>; }
  441. if($IndiceMin == 9) { $ligne = <FILE9>; }
  442. if($ligne){
  443. $ligne =~ s/\n//g;
  444. $dateligne = &Fct_RecupererDate($ligne,*TabDomainIIS,$domain);
  445. if($dateligne != 10000100100100100100){
  446. $TabFichComplet_valeurs{$IndiceMin} = [ $ligne , $dateligne ];
  447. # Les variables Min sont initialisees avec les donnees de la ligne suivante du fichier d'entree Min si la ligne n'est pas vide
  448. $DateMin = $TabFichComplet_valeurs{$IndiceMin}[2];
  449. $LigneMin = $TabFichComplet_valeurs{$IndiceMin}[1];
  450. }
  451. }else{
  452. $TabFichComplet_env{$IndiceMin}[1]++;
  453. $TabFichComplet_valeurs{$IndiceMin}[2] = "99999999999999";
  454. $DateMin = $TabFichComplet_valeurs{$IndiceMin}[2];
  455. $LigneMin = "";
  456. }
  457. }else{
  458. # On a atteint la fin du fichier donc on positionne la DateCourant Min comme MAX=99999999999999
  459. $TabFichComplet_valeurs{$IndiceMin}[2] = "99999999999999";
  460. $DateMin = $TabFichComplet_valeurs{$IndiceMin}[2];
  461. $LigneMin = "";
  462. }
  463. }else{
  464. # On a atteint la fin du fichier donc on positionne la DateCourant Min comme MAX=99999999999999
  465. $TabFichComplet_valeurs{$IndiceMin}[2] = "99999999999999";
  466. $DateMin = $TabFichComplet_valeurs{$IndiceMin}[2];
  467. $LigneMin = "";
  468. }
  469. }
  470. }
  471. $Boucle = 0;
  472. for($indice = 0; $indice < $NumeroFichier ; $indice++) {
  473. if($TabFichComplet_env{$indice}[1]<=$TabFichComplet_env{$indice}[2]){ $Boucle = 1; }
  474. }
  475. }
  476. if($F[0] eq "Ouvert"){ close(FILE0); }
  477. if($F[1] eq "Ouvert"){ close(FILE1); }
  478. if($F[2] eq "Ouvert"){ close(FILE2); }
  479. if($F[3] eq "Ouvert"){ close(FILE3); }
  480. if($F[4] eq "Ouvert"){ close(FILE4); }
  481. if($F[5] eq "Ouvert"){ close(FILE5); }
  482. if($F[6] eq "Ouvert"){ close(FILE6); }
  483. if($F[7] eq "Ouvert"){ close(FILE7); }
  484. if($F[8] eq "Ouvert"){ close(FILE8); }
  485. if($F[9] eq "Ouvert"){ close(FILE9); }
  486. close(FICHIERCOURANT);
  487. select(FICHIER);
  488. }
  489. }
  490. }
  491.  
  492.  
  493. sub Fct_RecupererDate {
  494. local($ligne,*TabDomainIIS,$domain) = @_;
  495. my $DateFct = $Jour = $Mois = $Annee = $Temps = '';
  496. if (defined $TabDomainIIS{$domain}) {
  497. if(!$ligne){
  498. return "10000100100100100100";
  499. }else{
  500. # regexp = '....-..-.....:..:..';
  501. $_ = $ligne;
  502. if(/(....)-(..)-(..).(..):(..):(..)/){
  503. $ExtractAnnee = $1; $ExtractMois = $2; $ExtractJour = $3; $ExtractHeure = $4; $ExtractMinute = $5; $ExtractSeconde = $6;
  504. $DateDebutLigne = $ExtractAnnee.$ExtractMois.$ExtractJour.$ExtractHeure.$ExtractMinute.$ExtractSeconde;
  505. return $DateDebutLigne;
  506. }else{
  507. print 'ERROR : Pb de ligne pour le domain : '.$domain;
  508. print 'ERROR : Pas de Date dans la ligne : '.$ligne;
  509. }
  510. }
  511. }else{
  512. # regexp = "[..\/...\/....:..:..:.. ";
  513. if(!$ligne){
  514. return "10000100100100100100";
  515. }else{
  516. $_ = $ligne;
  517. if(/(..).(...).(....):(..):(..):(..)/){
  518. $ExtractAnnee = $3; $ExtractJour = $1; $ExtractHeure = $4; $ExtractMinute = $5; $ExtractSeconde = $6;
  519. $_ = $2;
  520. if(/Jan/) { $Mois = "01"; }
  521. if(/Feb/) { $Mois = "02"; }
  522. if(/Mar/) { $Mois = "03"; }
  523. if(/Apr/) { $Mois = "04"; }
  524. if(/May/) { $Mois = "05"; }
  525. if(/Jun/) { $Mois = "06"; }
  526. if(/Jul/) { $Mois = "07"; }
  527. if(/Aug/) { $Mois = "08"; }
  528. if(/Sep/) { $Mois = "09"; }
  529. if(/Oct/) { $Mois = "10"; }
  530. if(/Nov/) { $Mois = "11"; }
  531. if(/Dec/) { $Mois = "12"; }
  532. $DateDebutLigne = $ExtractAnnee.$Mois.$ExtractJour.$ExtractHeure.$ExtractMinute.$ExtractSeconde;
  533. return $DateDebutLigne;
  534. }else{
  535. print 'ERROR : Pb de ligne pour le domain : '.$domain;
  536. print 'ERROR : Pas de Date dans la ligne : '.$ligne;
  537. }
  538. }
  539. }
  540. }
  541.  
  542. 1;
Add Comment
Please, Sign In to add comment
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!