Août 112011
 

la commande « sleep x » sous Unix permet de faire une pause de x secondes.

je viens de trouver une commande perl assez satisfaisante permettant de faire des pause de moins d’une seconde.
intéressant par exemple lorsque l’on fork des process.
en effet, s’il n’y a pas de pause dans le script, lorsque les forks se terminent, ils restent en état zombie.
Continue reading »

Juin 102011
 

bdf amélioré sur une seule ligne:

  • affiche sur une seule ligne chaque FS
  • affiche le type de FS
  • affiche les Inodes
  • convertit les tailles dans un format humainement lisible
  • affiche un total de l’espace présent/utilisé/disponible en fin
Download : bdf.pl

#!/usr/bin/perl -w
#
# vim:tabstop=3:syntax=perl:
#
# ---------
## Script  : bdf.pl
## Version : 2.0
## Objet   : bdf ameliore
##----------------------------------------------------------------------------
# 0.1 27-aou-09 - Creation Cedrick Gaillard
# 2.0 31-aou-09 - Optimisation du temps d'execution
#               - Prise en compte des arguments de bdf
#               - n'affiche plus le total s'il n'y a qu'une ligne
#               - n'affiche plus l'entete si pas de FS a afficher.
#-----------------------------------------------------------------------------
#
# ce script remet en forme l'output de bdf:
#   - les tailles sont humainement lisible
#   - afiche en colonne claires et espacees
#   - affiche l'utilisation des inodes
#   - affiche le total de l'espace existant/utilise/disponible
#   - prend en compte tous les arguments de bdf ( -t nfs | -l | -s ...)
#-----------------------------------------------------------------------------

use strict ;
use warnings ;
use Time::HiRes qw( gettimeofday tv_interval) ;

# Initialisations
my (@suff) = qw(K M G T P E Z Y);
my $max_iterations = $#suff;

# On recupere la sortie du bdf
open (BDF,"bdf -i @ARGV |") or die "bdf: $!\n" ;

# On recupere les types de FS presents mont�s sur le systeme
open(MNTTAB,"</etc/mnttab") or die "/etc/mnttab: $!\n" ;
my @mnt_brut = <MNTTAB> ;
my (%fs_type) ;
foreach my $mnt_line (@mnt_brut) {
	my @mnt_line = split(' ',$mnt_line) ;
	next if( $mnt_line[2] =~ m/autofs/ ) ;
	$fs_type{$mnt_line[0]} = ( $mnt_line[2] ) ;
}
close( MNTTAB );

# Fonction retournant les nombres convertis avec leur suffixe.
sub calc_number {
	my ($number) = @_;
	my $iteration = 0;
	while ( $number > 1023 ) {
		last if ($iteration >= $max_iterations);
		$iteration++ ;
		$number = ($number / 1024);
	}
	$number = sprintf("%.2f",$number) ;
	if( $number =~ m/\.00/ ){
		$number = sprintf("%d",$number) ;
	}
	$number = sprintf("%s%s",$number, $suff[$iteration]) ;
	return ($number) ;
}

# generation d'un tableau, sort un pointeur vers ce tableau
sub generateur_ref_tab {
	my @t = () ;
	return \@t ;
}

# pour la premiere ligne
my @entte = (
	'File System',
	'Size',
	'Used',
	'Avail',
	'%Used',
	'Inodes',
	'IFree',
	'%IUsed',
	'Mounted on',
	'Type'
) ;

my $index = 1 ;
my $seconde_passe = 0 ;
my $length = 10 ;
my ($bdf_line, $nb_elem, $ref_bdf, @bdf_temp_1, @bdf_one_line) ;
my ($ttotal, $utotal, $atotal) = 0 ;

# Le premier enregistrement contenant le header
($bdf_one_line[0]) = (\@entte) ;

foreach $bdf_line (<BDF>) {
	next if( $bdf_line =~ m/^Filesystem/ ) ;
	chomp $bdf_line ;

	if( $seconde_passe == 0 ){
		@bdf_temp_1  = split(' ',$bdf_line) ;
		$ref_bdf = generateur_ref_tab() ;
	}
	else {
		$seconde_passe = 0 ;
		my $bdf_temp = join(' ', @bdf_temp_1, $bdf_line) ;
		@bdf_temp_1  = split(' ',$bdf_temp) ;
	}

	($nb_elem) = $#bdf_temp_1 ;
	if( $nb_elem <= 1 ) {
		$seconde_passe = 1 ;
		next ;
	}

	# Calcul de la taille la plus grande
	if( length($bdf_temp_1&#91;0&#93;) > $length ) {
		$length = length($bdf_temp_1[0]) ;
	}

	# Total des valeurs
	$ttotal += $bdf_temp_1[1] ;
	$utotal += $bdf_temp_1[2] ;
	$atotal += $bdf_temp_1[3] ;

	# Valeurs calculees
	$bdf_temp_1[1] = calc_number($bdf_temp_1[1]) ;
	$bdf_temp_1[2] = calc_number($bdf_temp_1[2]) ;
	$bdf_temp_1[3] = calc_number($bdf_temp_1[3]) ;

	# On rajoute un champ pour garder l'ordre
	$bdf_temp_1[9] = $bdf_temp_1[8] ;

	# Type de FS
	$bdf_temp_1[8] = $fs_type{$bdf_temp_1[0]} ;

	# On place toute la ligne dans le tableau reference
	(@$ref_bdf) = (@bdf_temp_1) ;
	($bdf_one_line[$index]) = ($ref_bdf) ;

	# On incremente
	$index++ ;
}

if ( $index <= 1 ) {
	print "Pas de FileSysteme a afficher\n" ;
	exit(0) ;
}

#Format
my $lengthFS = $length ;
my $lengthNB = 8 ;

$index = 0 ;

my ($t, $tk, $u, $uk, $a, $ak) ;
my ($fs, $pu, $iu, $if, $pi, $mo, $ty) ;
foreach (@bdf_one_line) {
	$fs = $bdf_one_line&#91;$index&#93;&#91;0&#93; ;
	$t  = $bdf_one_line&#91;$index&#93;&#91;1&#93; ;
	$u  = $bdf_one_line&#91;$index&#93;&#91;2&#93; ;
	$a  = $bdf_one_line&#91;$index&#93;&#91;3&#93; ;
	$pu = $bdf_one_line&#91;$index&#93;&#91;4&#93; ;
	$iu = $bdf_one_line&#91;$index&#93;&#91;5&#93; ;
	$if = $bdf_one_line&#91;$index&#93;&#91;6&#93; ;
	$pi = $bdf_one_line&#91;$index&#93;&#91;7&#93; ;
	$ty = $bdf_one_line&#91;$index&#93;&#91;8&#93; ;
	$mo = $bdf_one_line&#91;$index&#93;&#91;9&#93; ;

	printf( "%-${lengthFS}s %${lengthNB}s %${lengthNB}s %${lengthNB}s %5s %${lengthNB}s %${lengthNB}s %6s %4s %-${lengthNB}s\n",$fs, $t, $u, $a, $pu, $iu, $if, $pi, $ty, $mo) ;
	$index++ ;
}

# On affiche pas le total s'il n'y a qu'une ligne
if ( $index > 2 ) {
	($ttotal) = calc_number($ttotal) ;
	($utotal) = calc_number($utotal) ;
	($atotal) = calc_number($atotal) ;
	printf( "%${lengthFS}s %${lengthNB}s %${lengthNB}s %${lengthNB}s\n","Total:", $ttotal, $utotal, $atotal);
}

exemple de sortie :

$ bdf.pl
File System         Size     Used    Avail %Used   Inodes    IFree %IUsed Type Mounted on
/dev/vg00/lvol3    1.97G  314.57M    1.65G   16%     2581    54443     5% vxfs /
/dev/vg00/lvol1    1024M  147.29M  869.96M   14%      144    28048     1% vxfs /stand
/dev/vg00/lvol8       6G    3.44G    2.54G   58%    42861    83763    34% vxfs /var
/dev/vg00/lvol7       4G    3.25G  761.31M   81%    56491    24533    70% vxfs /usr
/dev/vg00/lvol6    7.81G    3.09G    4.69G   40%    55047   154809    26% vxfs /opt
/dev/vg00/lvol5       2G   16.38M    1.97G    1%       12    64980     0% vxfs /tmp
/dev/vg00/lvol4       2G   16.29M    1.97G    1%        4    64988     0% vxfs /data
         Total:   24.78G   10.26G   14.40G
 Publié par à 12 h 50 min  Taggué avec :
Juin 092011
 

voici une fonction permettant de calculer le temps qu’utilise un élément d’un script perl.

Download : calcultime.pl

#!/usr/bin/perl
use strict ;
use warnings ;
use Time::HiRes qw( gettimeofday tv_interval) ;
 
sub calcultime {
	my ($seconds, $microseconds) = gettimeofday;
	if( !ref($_[0]) ) {
		my $ref = [ ($seconds, $microseconds) ] ;
		return ($ref) ;
	}
	else {
		my ($oldtime, $name) = @_ ;
		my ($oldseconds, $oldmicroseconds) = @$oldtime ;
		my $elapsed = tv_interval( [$oldseconds, $oldmicroseconds, [$seconds, $microseconds]] );
		return($elapsed);
	}
}

utilisation:
Continue reading »

 Publié par à 15 h 54 min  Taggué avec :