Fedora-Fr

Ce site est optimisé pour être consulté depuis un navigateur moderne dans lequel JavaScript est activé.

Bash - premier script, tests réseau.

Nawak

Salut,

Voici mon premier "vrai" script, réalisé pour mon stage en réseau.

Mon objectif est d'améliorer la qualité du réseau, dispersé sur plusieurs sites, concernant quelques points précis. Il est donc crée d'aprés mes quelques bases, des sources internet et un peu d'aide extérieur. Mon but est de tester les performances (bande passante) d'un réseau pour en détecter les faiblesses concernant :
- le D/L FTP
- le D/L HTML
- le D/L HTML avec proxy

J'ai donc réalisé une série de "logs", auxquels j'ai ajouté de quoi mesurer les performances brutes :
- une liste de "ping(s)" simples
- le résultat d'un benchmark réseau, iperf.

Il faut d'abord créer une machine qui fera serveur FTP (compte anonymous), HTML et Iperf (en mode serveur), puis déposer un fichier nommé "fake" de plusieurs mégas (50 Mo pour mes tests), avant de placer la machine au plus proche du coeur de réseau. Sur la machine client, installer iperf sous linux (le reste des outils étant standard).

Pour les mesures de référence, lancer le script sur le client linux, elle aussi proche du coeur de réseau. Ensuite, déplacer le client linux en divers endroits du réseau et lancer le script, comparer les logs une fois les tests achevés, afin d'en tirer les conclusions.

Voilà, j'ai expliqué ce que j'ai voulu faire, et je met le tout ici avec l'espoir de retours de pros connaissant mieux le Bash que moi, afin de :
1- optimiser le script (ou au moins me donner des pistes)
2- apporter des modifications/retouches (pour les plus gentils)
3- améliorer les tests (utilisation des outils, nouveaux outils ?)
4- évaluer la pertinence des tests réseaux (résultats en retour)

J'espère déjà avoir un feedback ici, je ne pense pas trouver meilleur endroit qu'un forum traîtant de Linux en général, Fedora en particulier. M'enfin, si vous avez des adresses, n'hésitez pas.
🙂

#! /bin/bash
# bash script - Fedora Core 5
clear

# Déclaration de variables 
ip=$1
min_ip=1
max_ip=254

# Message d'indication si aucun paramètre
if [ $# -ne 1 ];
then
    clear
    echo "Veuillez entrer un paramètre."
    echo "Utilisation : `basename $0` [IP du serveur]"
    echo "-----------------------------------"
    exit 0
fi

# Test pour savoir si les octets sont des caractères numériques
function isNum
{
    if [ $# = 1 ];
    then
    tmp=`expr "$1" : '([0-9]{1,})'`
        
        if [ "$1" = "$tmp" ];
        then
            echo 0
        else
            echo 1
        fi
    else
        echo 2
    fi
}

# Test pour savoir si les octets sont compris entre 0 et 255
function minMax
{
    if [ $# = 3 ];
    then
        nbr=$1
        min=$2
        max=$3
    
        if [ "$nbr" -ge "$min" -a "$nbr" -le "$max" ];
        then
            echo 0
        else
            echo 1
        fi
    else
        echo 2
    fi
}

# Routine de test pour la validité de l'adresse IP
for i in 1 2 3 4;
    do
    octet=`echo $ip | cut -d "." -f$i`

    if [ `isNum $octet` -eq 0 ];
        then
            if [ `minMax $octet $min_ip $max_ip` -eq 0 ];
            then
                echo "l'octet $i [$octet] est valide."
            else
                echo "l'octet $i [$octet] est incorrect."
                echo "Notation décimale IPv4 requise, sans adresse de réseau ni broadcast."
                exit 1
            fi
        else
            echo "L'octet $i [$octet] est incorrect."
            echo "Notation décimale IPv4 requise."
            exit 1
    fi
done

# Récupération ip/masque/broadcast de l'hôte (ici l'IP seul)
function hostip (){
    way=$1 #chemin de ifconfig ('sbin/ifconfig')
    eth=$2 #numéro d'interface ('eth0')

    mask1=`$way $eth|grep Masque|cut -d ':' -f4|cut -d '.' -f1`
    mask2=`$way $eth|grep Masque|cut -d ':' -f4|cut -d '.' -f2`
    mask3=`$way $eth|grep Masque|cut -d ':' -f4|cut -d '.' -f3`
    mask4=`$way $eth|grep Masque|cut -d ':' -f4|cut -d '.' -f4`
    
    ip1=`$way $eth|grep Masque|cut -d ':' -f2|cut -d '.' -f1`
    ip2=`$way $eth|grep Masque|cut -d ':' -f2|cut -d '.' -f2`
    ip3=`$way $eth|grep Masque|cut -d ':' -f2|cut -d '.' -f3`
    ip4=`$way $eth|grep Masque|cut -d ':' -f2|cut -d '.' -f4|cut -d ' ' -f1`
    
    mask=`$way $eth|grep Masque|cut -d ':' -f4`
    #echo $mask
    ethip=`$way $eth|grep Masque|cut -d ':' -f2|cut -d ' ' -f1`
    echo $ethip
    ip_res=$[${mask1} & ${ip1}]"."$[${mask2} & ${ip2}]"."$[${mask3} & ${ip3}]"."$[${mask4} & ${ip4}]
    #echo $ip_res
}

# Mesures basiques via ping
function Mping(){
    ping -c 30 $ip >> $log
}

# Mesures d'un téléchargement FTP
function Mftp(){
    wget -r -4 -a $log --progress=dot:mega --proxy=off --no-cache --no-proxy --no-passive-ftp --user anonymous --password anonymous ftp://$ip/fake
    rm -r $ip
}

# Mesures d'un téléchargement HTTP
function Mhttp(){
    wget -r -4 -a $log --progress=dot:mega --proxy=off --cache=off --no-dns --user anonymous --password anonymous http://$ip/fake
    rm -r $ip
}

# Mesures d'un téléchargement HTTP via un proxy
function Mhttpp(){
    export http_proxy="http://10.1.1.3:8080" #Utilisation de la variable d'environnement
    wget -r -4 -a $log --progress=dot:mega --proxy=on --cache=off --no-dns --user anonymous --password anonymous http://$ip/fake
    rm -r $ip
}

# Mesures en client/serveur iperf
function Miperf(){
    iperf -c $ip -P 0 -i 5 -f M -t 60 >> $log # sur 60 sec en TCP, 1 mesure/5 sec.
}

function Mcomplet(){
    echo "" >> $log
    echo "Mesure 1 : ping"
    echo "-------------------------------------------------------------" >> $log
    echo "Mesure 1 : ping" >> $log
    echo "-------------------------------------------------------------" >> $log
    Mping $log

    echo "" >> $log
    echo "Mesure 2 : wget FTP"
    echo "-------------------------------------------------------------" >> $log
    echo "Mesure 2 : wget FTP" >> $log
    echo "-------------------------------------------------------------" >> $log
    Mftp $log

    echo "" >> $log
    echo "Mesure 3 : wget HTTP"
    echo "-------------------------------------------------------------" >> $log
    echo "Mesure 3 : wget HTTP" >> $log
    echo "-------------------------------------------------------------" >> $log
    Mhttp $log

    echo "" >> $log
    echo "Mesure 4 : wget HTTP + Proxy"
    echo "-------------------------------------------------------------" >> $log
    echo "Mesure 4 : wget HTTP + Proxy" >> $log
    echo "-------------------------------------------------------------" >> $log
    Mhttpp $log

    echo "" >> $log
    echo "Mesure 5 : iperf"
    echo "-------------------------------------------------------------" >> $log
    echo "Mesure 5 : iperf" >> $log
    echo "-------------------------------------------------------------" >> $log
    Miperf $log
}

# Création du log et aiguillage vers le type de mesure adéquat.
function mesure () {
    # Indication à l'écran pour patienter
    echo "Veuillez patienter svp..."

    # Création du nom de fichier log
    log=$1

    # Liste la date et l'heure
    echo "------------------------------" > $log
    echo `date` >> $log
    echo "------------------------------" >> $log
    echo "" >> $log

    # Ajoute le nom d'hôte et l'adresse IP de l'interface 0
    echo `hostname` >> $log
    hostip '/sbin/ifconfig' 'eth0' >> $log
    echo "" >> $log

    # Ligne de séparation avant mesures
    echo "-------------------------------------------------------------" >> $log
    echo "" >> $log

    # Test sur le type de fichier log pour lancer le test approprié
    case $log in
        logping) Mping $log;;
        logftp) Mftp $log;;
        loghtml) Mhttp $log;;
        loghtmlp) Mhttpp $log;;
        logiperf) Miperf $log;;
        logcomplet) Mcomplet $log;;
    esac        
}


# Gestion du menu de choix pour le type de mesures à effectuer
function bye(){
    echo "Mesures terminées. Bonne journée !"
    echo "Les résultats sont dans le fichier '$log'"
    echo ":)"
}

function menu(){
    clear
    echo "-----------------------------------------------------"
    echo "|              Choix du protocole de test           |"
    echo "-----------------------------------------------------"
    echo "Appuyez sur une touche, puis validez. [7] pour quitter."
    echo ""
    select j in  'PING' 'FTP' 'HTTP' 'HTTP+PROXY' 'IPERF' 'TOUS' 'QUIT'
        do
            case $j in
                PING)
                mesure logping
                bye
                exit 0;;

                FTP)
                mesure logftp
                bye
                exit 0;;
        
                HTTP)
                mesure loghttp
                bye
                exit 0;;
        
                HTTP+PROXY)
                mesure loghttpp
                bye
                exit 0;;
            
                IPERF)
                mesure logiperf
                bye
                exit 0;;

                TOUS)
                mesure logcomplet
                bye
                exit 0;;
        
                QUIT)
                clear
                echo "Script terminé. Bonne journée."
                exit 0;;
    
                *)
                echo "Veuillez entrer un chiffre entre 1 et 6. Merci."
                echo "Touche '7' pour quitter, 'ctrl+d' pour interrompre";;
            esac
    done 
}
menu

Anvil

Je ne jugerai pas de l'interet ni de la semantique du script (sinon on va encore penser que je suis de mauvaise foi), fais toi la main sur ce que tu juges bon. Mais voici quelques erreurs de style :
0. Ton script ne marchera pas sur une machine qui n'est pas en locale francais. Ton "grep Masque" ne passera pas si je suis en locale anglaise. Je te conseille de toujours forcer la locale au debut de tes scripts - le mieux c'est de le forcer en anglais, les traductions sont pluss sujettes au changement. Vois le man 7 locale
1. On ne met pas d'espace entre #! et /bin/bash - pas standard. L'ecriture avec un espace est heritée d'un vieux bug d'un BSD quelconque et ne doit pas etre utilisee.
2. Utilise la syntaxe $(foo) au lieu de `foo` - recommandation POSIX.
3. Evite ce genre de chose. Apprend plutot a faire des boucles et des tableaux en shell (voir le man bash)

     mask1=`$way $eth|grep Masque|cut -d ':' -f4|cut -d '.' -f1`
    mask2=`$way $eth|grep Masque|cut -d ':' -f4|cut -d '.' -f2`
    mask3=`$way $eth|grep Masque|cut -d ':' -f4|cut -d '.' -f3`
    mask4=`$way $eth|grep Masque|cut -d ':' -f4|cut -d '.' -f4`

-->

for i in $(seq 4)
  do
  mask[$i]="$($way $eth|grep Masque|cut -d ':' -f4|cut -d '.' -f$i)"
done
echo ${mask[3]} # 3eme element.

4. Au lieu de ca :

    echo "" >> $log
    echo "Mesure 1 : ping"
    echo "-------------------------------------------------------------" >> $log
    echo "Mesure 1 : ping" >> $log
    echo "-------------------------------------------------------------" >> $log

Fais ca :

cat <<UNTRUC >> $log

Mesure 1 : ping
-------------------------------------------------------------
Mesure 1 : ping
-------------------------------------------------------------
UNTRUC

C'est moins chiant a ecrire et un poil pluss maintenable.
5. Encore des trucs repetitifs :

                PING)
                mesure logping
                bye
                exit 0;;

                FTP)
                mesure logftp
                bye
                exit 0;;

Ca peut devenir

                PING|FTP)
                mesure log$(echo $j|tr '[A-Z]' '[a-z]')
                bye
                exit 0;;

Ca serait encore plus simple aussi si tu ne faisais qu'une seule fonction et que tu passais le protocole en parametre..

"Never write the same thing twice". Bon courage.

Nawak

Salut, et merci.

Avec les divers conseils (fedora-france et développez.com), j'ai remanié le script. Même si ce n'est pas parfait, ça a déjà plus de gueule. Par contre, ton code :

less << TXT >> $log
Mesure 1 : ping
-------------------------------------------------------------
Mesure 1 : ping
-------------------------------------------------------------
TXT

Me provoque une erreur en fin de script (toujours sur la dernière ligne), et quand je repasse à l'ancienne méthode, tout roule (pareil avec cat).

Sinon, voilà le script remanié :

#!/bin/bash
# bash script - Fedora Core 5
clear
LC_ALL=fr_FR.utf8

# Déclaration de variables 
ip=$1

# Message d'indication si aucun paramètre
if [ $# != 1 ];
then
    clear
    echo "Veuillez entrer un paramètre."
    echo "Utilisation : $(basename $0) [IP du serveur]"
    echo "-----------------------------------"
    exit 0
fi

# Utilise le retour de la fonction testant la validité de l'IP
function wrong {
    echo "Notation décimale IPv4 requise."
    exit 0
}

# Test de validité IPv4 de l'adresse entrée (expression régulière)
function isIPv4 {
    if [ $# = 1 ]
    then
        printf $1 | grep -Eq '^((25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?).){3}(25[0-4]|2[0-4][0-9]|[01]?[1-9][0-9]?)$'
        return $?
    else
        return 2
    fi
}
isIPv4 $ip && echo "IP validée." || wrong

# Récupération de l'ip, du masque de sous-réseau et de l'adresse de broadcast de l'hôte
function hostip {
    way=$1 #chemin de ifconfig ('sbin/ifconfig')
    eth=$2 #numéro d'interface ('eth0')

    for i in $(seq 4)
      do
          mask[$i]="$($way $eth|grep Masque|cut -d ':' -f4|cut -d '.' -f$i)"
        octet[$i]="$($way $eth|grep Masque|cut -d ':' -f2|cut -d '.' -f$i|cut -d ' ' -f1)"
    done
    
    # Variable donnant l'IP de l'hôte
    adress=${octet[1]}"."${octet[2]}"."${octet[3]}"."${octet[4]}
    #echo "$adress"

    # Variable donnant le masque de sous-réseau
    subnet=${mask[1]}"."${mask[2]}"."${mask[3]}"."${mask[4]}
    #echo "$subnet"

    # Variable donnant l'adresse du réseau
    network=$[${mask[1]} & ${octet[1]}]"."$[${mask[2]} & ${octet[2]}]"."$[${mask[3]} & ${octet[3]}]"."$[${mask[4]} & ${octet[4]}]
    #echo "$network"

    echo "IP de l'hôte : $adress"
    echo "Sous-réseau : $subnet"
    echo "Réseau : $network"
}
#hostip /sbin/ifconfig eth0

# ------------------------------------------------------------
# penser à créer un utilisateur anonymous, passwd anonymous
# plus gestion des droits : sudo chmod ugo+rwx /home/anonymous
# ------------------------------------------------------------

# Mesures basiques via ping
function Mping(){
    ping -c 30 $ip >> $log
}

# Mesures d'un téléchargement FTP
function Mftp(){
    wget -r -4 -a $log --progress=dot:mega --proxy=off --no-cache --no-proxy --no-passive-ftp --user anonymous --password anonymous ftp://$ip/fake
    rm -r $ip
}

# Mesures d'un téléchargement HTTP
function Mhttp(){
    wget -r -4 -a $log --progress=dot:mega --proxy=off --cache=off --no-dns --user anonymous --password anonymous http://$ip/fake
    rm -r $ip
}

# Mesures d'un téléchargement HTTP via un proxy
function Mhttpp(){
    export http_proxy="http://10.1.1.3:8080" #Utilisation de la variable d'environnement
    wget -r -4 -a $log --progress=dot:mega --proxy=on --cache=off --no-dns --user anonymous --password anonymous http://$ip/fake
    rm -r $ip
}

# Mesures en client/serveur iperf
function Miperf(){
    iperf -c $ip -P 0 -i 5 -f M -t 60 >> $log # sur 60 sec en TCP, 1 mesure/5 sec.
}

function Mcomplet(){
    echo "" >> $log
    echo "Mesure 1 : ping"
    echo "-------------------------------------------------------------" >> $log
    echo "Mesure 1 : ping" >> $log
    echo "-------------------------------------------------------------" >> $log
    Mping $log

    echo "" >> $log
    echo "Mesure 2 : wget FTP"
    echo "-------------------------------------------------------------" >> $log
    echo "Mesure 2 : wget FTP" >> $log
    echo "-------------------------------------------------------------" >> $log
    Mftp $log

    echo "" >> $log
    echo "Mesure 3 : wget HTTP"
    echo "-------------------------------------------------------------" >> $log
    echo "Mesure 3 : wget HTTP" >> $log
    echo "-------------------------------------------------------------" >> $log
    Mhttp $log

    echo "" >> $log
    echo "Mesure 4 : wget HTTP + Proxy"
    echo "-------------------------------------------------------------" >> $log
    echo "Mesure 4 : wget HTTP + Proxy" >> $log
    echo "-------------------------------------------------------------" >> $log
    Mhttpp $log

    echo "" >> $log
    echo "Mesure 5 : iperf"
    echo "-------------------------------------------------------------" >> $log
    echo "Mesure 5 : iperf" >> $log
    echo "-------------------------------------------------------------" >> $log
    Miperf $log
}

# Création du log et aiguillage vers le type de mesure adéquat.
function mesure () {
    # Indication à l'écran pour patienter
    echo "Veuillez patienter svp..."

    # Création du nom de fichier log
    log=$1

    # Liste la date et l'heure
    echo "------------------------------" > $log
    echo $(date) >> $log
    echo "------------------------------" >> $log
    echo "" >> $log

    # Ajoute le nom d'hôte et l'adresse IP de l'interface 0
    echo "Nom de l'hôte : $(hostname)" >> $log
    hostip '/sbin/ifconfig' 'eth0' >> $log
    echo "" >> $log

    # Ligne de séparation avant mesures
    echo "-------------------------------------------------------------" >> $log
    echo "" >> $log

    # Test sur le type de fichier log pour lancer le test approprié
    case $log in
        logping) Mping $log;;
        logftp) Mftp $log;;
        loghttp) Mhttp $log;;
        loghttpp) Mhttpp $log;;
        logiperf) Miperf $log;;
        logcomplet) Mcomplet $log;;
    esac        
}


# Gestion du menu de choix pour le type de mesures à effectuer
function bye(){
    echo "Mesures terminées. Bonne journée !"
    echo "Les résultats sont dans le fichier '$log'"
    echo ":)"
}

function menu(){
    clear
    echo "-----------------------------------------------------"
    echo "|              Choix du protocole de test           |"
    echo "-----------------------------------------------------"
    echo "Appuyez sur une touche, puis validez. [7] pour quitter."
    echo ""
    select j in  'PING' 'FTP' 'HTTP' 'HTTP+PROXY' 'IPERF' 'TOUS' 'QUIT'
        do
            case $j in
                PING|FTP|HTTP|HTTP+PROXY|IPERF|TOUS)
                mesure log$(echo $j|tr '[A-Z]' '[a-z]')
                bye
                exit 0;;
        
                QUIT)
                clear
                echo "Script terminé. Bonne journée."
                exit 0;;
    
                *)
                echo "Veuillez entrer un chiffre entre 1 et 6. Merci."
                echo "Touche '7' pour quitter, 'ctrl+d' pour interrompre";;
            esac
    done 
}
menu

Celui-ci fonctionne correctement, il est tout aussi clair, même s'il reste encore des choses à améliorer.
:-D

Anvil

Me provoque une erreur en fin de script (toujours sur la dernière ligne)

"chez moi ca marche".

Quelle erreur ? A quel endroit ? Passe le script en "#!/bin/bash -x" et colle voir la portion ou ca affiche l'erreur..

Nawak

re,

Voilà le résultat demandé :

+ LC_ALL=fr_FR.utf8
+ ip=10.1.160.181
+ '[' 1 '!=' 1 ']'
+ isIPv4 10.1.160.181
+ '[' 1 = 1 ']'
+ printf 10.1.160.181
+ grep -Eq '^((25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?).){3}(25[0-4]|2[0-4][0-9]|[01]?[1-9][0-9]?)$'
+ return 0
+ echo 'IP validée.'
IP validée.
./bench3: line 214: syntax error: unexpected end of file

Et à chaque fois, j'ai cette "fin de fichier inattendue".
C'est clairement lié à la portion :

less << TXT >> $log
echo "------------------------------"
echo $(date)
echo "------------------------------"
echo ""
TXT

Puisque quand je l'enlève, tout rentre dans l'ordre.

Temet

EDIT : j'ai dit une connerie ... pardon :x

TitaX

less << TXT >> $log
echo "------------------------------"
echo $(date)
echo "------------------------------"
echo ""
TXT

recommence en retirant les "echo" pour voir

Anvil

Je viens de relever, mais ton LC_ALL, il faut l'exporter, sinon les processus files ne verront pas la couleur de cette variable (d'ou le "unexpected end of file" au lieu de "fin de fichier inattendue").

On peut voir le script avec les cat << au lieu des echo ? Je pense qu'il y a une erreur de syntaxe quelque part *ailleurs*

Anvil

TitaX : ca affiche pas ce qu'on veut mais ca marche aussi.

Nawak

J'ai fait un tas de tests, mais rien ne fonctionne tant que je n'ai pas retiré ces $ù*;:,°" de listes. Voici le script entier, avec dedans le morceau qui pose problème (je log un truc au niveau de la date et l'heure dans la fonction "mesure"). Je pense pourtant avoir effectué l'export des variables de langues, mais visiblement, bah... non.

#!/bin/bash
# bash script - Fedora Core 5
clear
export LC_ALL="fr_FR"
export LC_CTYPE="ISO-8859-15"
export LANGUAGE="fr_FR"
export LC_MESSAGES="fr_FR"
export LANG="fr_FR"
export LESSCHARSET="latin1"
export LC_MONETARY="fr_FR@euro"
export LC_NUMERIC="fr_FR"
export LC_TIME="fr_FR"

# Déclaration de variables 
ip=$1

# Message d'indication si aucun paramètre
if [ $# != 1 ];
then
    clear
    echo "Veuillez entrer un paramètre."
    echo "Utilisation : $(basename $0) [IP du serveur]"
    echo "-----------------------------------"
    exit 0
fi

# Utilise le retour de la fonction testant la validité de l'IP
function wrong {
    echo "Notation décimale IPv4 requise."
    exit 0
}

# Test de validité IPv4 de l'adresse entrée (expression régulière)
function isIPv4 {
    if [ $# = 1 ]
    then
        printf $1 | grep -Eq '^((25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?).){3}(25[0-4]|2[0-4][0-9]|[01]?[1-9][0-9]?)$'
        return $?
    else
        return 2
    fi
}
isIPv4 $ip && echo "IP validée." || wrong

# Récupération de l'ip, du masque de sous-réseau et de l'adresse de broadcast de l'hôte
function hostip {
    way=$1 #chemin de ifconfig ('sbin/ifconfig')
    eth=$2 #numéro d'interface ('eth0')

    for i in $(seq 4)
      do
          mask[$i]="$($way $eth|grep Masque|cut -d ':' -f4|cut -d '.' -f$i)"
        octet[$i]="$($way $eth|grep Masque|cut -d ':' -f2|cut -d '.' -f$i|cut -d ' ' -f1)"
    done
    
    # Variable donnant l'IP de l'hôte
    adress=${octet[1]}"."${octet[2]}"."${octet[3]}"."${octet[4]}
    #echo "$adress"

    # Variable donnant le masque de sous-réseau
    subnet=${mask[1]}"."${mask[2]}"."${mask[3]}"."${mask[4]}
    #echo "$subnet"

    # Variable donnant l'adresse du réseau
    network=$[${mask[1]} & ${octet[1]}]"."$[${mask[2]} & ${octet[2]}]"."$[${mask[3]} & ${octet[3]}]"."$[${mask[4]} & ${octet[4]}]
    #echo "$network"

    echo "IP de l'hôte : $adress"
    echo "Sous-réseau : $subnet"
    echo "Réseau : $network"
}
#hostip /sbin/ifconfig eth0

# ------------------------------------------------------------
# penser à créer un utilisateur anonymous, passwd anonymous
# plus gestion des droits : sudo chmod ugo+rwx /home/anonymous
# ------------------------------------------------------------

# Mesures basiques via ping
function Mping(){
    ping -c 30 $ip >> $log
}

# Mesures d'un téléchargement FTP
function Mftp(){
    wget -r -4 -a $log --progress=dot:mega --proxy=off --no-cache --no-proxy --no-passive-ftp --user anonymous --password anonymous ftp://$ip/fake
    rm -r $ip
}

# Mesures d'un téléchargement HTTP
function Mhttp(){
    wget -r -4 -a $log --progress=dot:mega --proxy=off --cache=off --no-dns --user anonymous --password anonymous http://$ip/fake
    rm -r $ip
}

# Mesures d'un téléchargement HTTP via un proxy
function Mhttpp(){
    export http_proxy="http://10.1.1.3:8080" #Utilisation de la variable d'environnement
    wget -r -4 -a $log --progress=dot:mega --proxy=on --cache=off --no-dns --user anonymous --password anonymous http://$ip/fake
    rm -r $ip
}

# Mesures en client/serveur iperf
function Miperf(){
    iperf -c $ip -P 0 -i 5 -f M -t 60 >> $log # sur 60 sec en TCP, 1 mesure/5 sec.
}

function Mcomplet(){
    echo "" >> $log
    echo "Mesure 1 : ping"
    echo "-------------------------------------------------------------" >> $log
    echo "Mesure 1 : ping" >> $log
    echo "-------------------------------------------------------------" >> $log
    Mping $log

    echo "" >> $log
    echo "Mesure 2 : wget FTP"
    echo "-------------------------------------------------------------" >> $log
    echo "Mesure 2 : wget FTP" >> $log
    echo "-------------------------------------------------------------" >> $log
    Mftp $log

    echo "" >> $log
    echo "Mesure 3 : wget HTTP"
    echo "-------------------------------------------------------------" >> $log
    echo "Mesure 3 : wget HTTP" >> $log
    echo "-------------------------------------------------------------" >> $log
    Mhttp $log

    echo "" >> $log
    echo "Mesure 4 : wget HTTP + Proxy"
    echo "-------------------------------------------------------------" >> $log
    echo "Mesure 4 : wget HTTP + Proxy" >> $log
    echo "-------------------------------------------------------------" >> $log
    Mhttpp $log

    echo "" >> $log
    echo "Mesure 5 : iperf"
    echo "-------------------------------------------------------------" >> $log
    echo "Mesure 5 : iperf" >> $log
    echo "-------------------------------------------------------------" >> $log
    Miperf $log
}

# Création du log et aiguillage vers le type de mesure adéquat.
function mesure () {
    # Indication à l'écran pour patienter
    echo "Veuillez patienter svp..."

    # Création du nom de fichier log
    log=$1

    # Liste la date et l'heure
    #echo "------------------------------" > $log
    #echo $(date) >> $log
    #echo "------------------------------" >> $log
    #echo "" >> $log

    # Liste la date et l'heure
    less << TXT >> $log
    echo "------------------------------"
    echo $(date)
    echo "------------------------------"
    echo ""
    TXT

    # Ajoute le nom d'hôte et l'adresse IP de l'interface 0
    echo "Nom de l'hôte : $(hostname)" >> $log
    hostip '/sbin/ifconfig' 'eth0' >> $log
    echo "" >> $log

    # Ligne de séparation avant mesures
    echo "-------------------------------------------------------------" >> $log
    echo "" >> $log

    # Test sur le type de fichier log pour lancer le test approprié
    case $log in
        logping) Mping $log;;
        logftp) Mftp $log;;
        loghttp) Mhttp $log;;
        loghttpp) Mhttpp $log;;
        logiperf) Miperf $log;;
        logcomplet) Mcomplet $log;;
    esac        
}


# Gestion du menu de choix pour le type de mesures à effectuer
function bye(){
    echo "Mesures terminées. Bonne journée !"
    echo "Les résultats sont dans le fichier '$log'"
    echo ":)"
}

function menu(){
    clear
    echo "-----------------------------------------------------"
    echo "|              Choix du protocole de test           |"
    echo "-----------------------------------------------------"
    echo "Appuyez sur une touche, puis validez. [7] pour quitter."
    echo ""
    select j in  'PING' 'FTP' 'HTTP' 'HTTP+PROXY' 'IPERF' 'TOUS' 'QUIT'
        do
            case $j in
                PING|FTP|HTTP|HTTP+PROXY|IPERF|TOUS)
                mesure log$(echo $j|tr '[A-Z]' '[a-z]')
                bye
                exit 0;;
        
                QUIT)
                clear
                echo "Script terminé. Bonne journée."
                exit 0;;
    
                *)
                echo "Veuillez entrer un chiffre entre 1 et 6. Merci."
                echo "Touche '7' pour quitter, 'ctrl+d' pour interrompre";;
            esac
    done 
}
menu

Anvil

export LC_ALL="fr_FR"
export LC_CTYPE="ISO-8859-15"
export LANGUAGE="fr_FR"
export LC_MESSAGES="fr_FR"
export LANG="fr_FR"
export LESSCHARSET="latin1"
export LC_MONETARY="fr_FR@euro"
export LC_NUMERIC="fr_FR"
export LC_TIME="fr_FR"

Quand LC_ALL existe, ca ne sert a rien de toucher aux autres LC_* ni a LANG. man 7 locale.

Nawak

Ok.
Lignes en cause retirées.

J'ai grugé avec des fonctions et des boucles pour virer les phrases redondantes. Du coup, ça prend moins de place. Cela pourrait être plus paramétrable, mais j'ai peur que cela devienne un poil complexe à créer. Voilà la dernière version, et à moins d'y voir des corrections nécessaires, je ne pense plus le retoucher :

#!/bin/bash
# bash script - Fedora Core 5
clear

# Localisation Fr
export LC_ALL="fr_FR.utf8"
export LESSCHARSET="latin1"

# Déclaration de variables 
ip=$1

# Message d'indication si aucun paramètre
if [ $# != 1 ];
then
    clear
    echo "Veuillez entrer un paramètre."
    echo "Utilisation : $(basename $0) [IP du serveur]"
    echo "---------------------------------------------------------------"
    exit 0
fi

# Utilise le retour de la fonction testant la validité de l'IP
function wrong {
    echo "Notation décimale IPv4 requise."
    exit 0
}

# Test de validité IPv4 de l'adresse entrée (expression régulière)
function isIPv4 {
    if [ $# = 1 ]
    then
        printf $1 | grep -Eq '^((25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?).){3}(25[0-4]|2[0-4][0-9]|[01]?[1-9][0-9]?)$'
        return $?
    else
        return 2
    fi
}
isIPv4 $ip && echo "IP validée." || wrong

# Récupération de l'ip, du masque de sous-réseau et de l'adresse de broadcast de l'hôte
function hostip {
    way=$1 #chemin de ifconfig ('sbin/ifconfig')
    eth=$2 #numéro d'interface ('eth0')

    for i in $(seq 4)
      do
          mask[$i]="$($way $eth|grep Masque|cut -d ':' -f4|cut -d '.' -f$i)"
        octet[$i]="$($way $eth|grep Masque|cut -d ':' -f2|cut -d '.' -f$i|cut -d ' ' -f1)"
    done
    
    # Variable donnant l'IP de l'hôte
    adress=${octet[1]}"."${octet[2]}"."${octet[3]}"."${octet[4]}
    #echo "$adress"

    # Variable donnant le masque de sous-réseau
    subnet=${mask[1]}"."${mask[2]}"."${mask[3]}"."${mask[4]}
    #echo "$subnet"

    # Variable donnant l'adresse du réseau
    network=$[${mask[1]} & ${octet[1]}]"."$[${mask[2]} & ${octet[2]}]"."$[${mask[3]} & ${octet[3]}]"."$[${mask[4]} & ${octet[4]}]
    #echo "$network"

    echo "IP de l'hôte : $adress"
    echo "Sous-réseau : $subnet"
    echo "Réseau : $network"
}

# Création du log et aiguillage vers le type de mesure adéquat.
function mesure () {
    # Indication à l'écran pour patienter
    echo "Veuillez patienter svp..."

    # Création du nom de fichier log
    log=$1

    # Liste la date et l'heure
    echo "---------------------------------------------------------------" > $log
    echo $(date) >> $log
    echo "---------------------------------------------------------------" >> $log
    echo "" >> $log

    # Ajoute le nom d'hôte et l'adresse IP de l'interface 0
    echo "Nom de l'hôte : $(hostname)" >> $log
    hostip '/sbin/ifconfig' 'eth0' >> $log
    echo "" >> $log

    # Ligne de séparation avant mesures
    echo "---------------------------------------------------------------" >> $log
    echo "" >> $log

    # Mesures basiques via ping
    function Mping(){
        ping -c 1 $ip > /dev/null #pour ne pas mesurer le premier délai (faussé)
        function MpingQoS(){
            case $1 in
            0x02) cmd="-c 10 -Q" type="QoS coût minimal";;
            0x04) cmd="-c 10 -Q" type="QoS fiabilité";;
            0x08) cmd="-c 10 -Q" type="QoS débit";;
            0x10) cmd="-c 10 -Q" type="QoS bas délai";;
            ff) cmd="-c 10 -p" type="paquet rempli";;
            esac
            
            echo "Ping '$type' ($1)" >> $log
            echo "---------------------------------------------------------------" >> $log
            ping $cmd $1 $ip >> $log
            echo "" >> $log
            echo "" >> $log
        }
        MpingQoS 0x02
        MpingQoS 0x04
        MpingQoS 0x08
        MpingQoS 0x10
        MpingQoS ff
    }
    
    # Mesures d'un téléchargement FTP
    function Mftp(){
        wget -r -4 -a $log --progress=dot:mega --proxy=off --no-cache --no-proxy --no-passive-ftp --user anonymous --password anonymous ftp://$ip/fake
        rm -r $ip
    }
    
    # Mesures d'un téléchargement HTTP
    function Mhttp(){
        wget -r -4 -a $log --progress=dot:mega --proxy=off --cache=off --no-dns --user anonymous --password anonymous http://$ip/fake
        rm -r $ip
    }
    
    # Mesures d'un téléchargement HTTP via un proxy
    function Mhttpp(){
        export http_proxy="http://10.1.1.3:8080" #Utilisation de la variable d'environnement
        wget -r -4 -a $log --progress=dot:mega --proxy=on --cache=off --no-dns --user anonymous --password anonymous http://$ip/fake
        rm -r $ip
    }
    
    # Mesures en client/serveur iperf
    function Miperf(){
        iperf -c $ip -P 0 -i 1 -f M -t 30 >> $log # sur 30 sec en TCP, 1 mesure/sec.
        echo "" >> $log
    }
    
    function Mall(){
        function boucle(){
            case $1 in
            1) nom="ping" mesure="Mping";;
            2) nom="wget FTP" mesure="Mftp";;
            3) nom="wget HTTP" mesure="Mhttp";;
            4) nom="wget HTTP + Proxy" mesure="Mhttpp";;
            5) nom="iperf" mesure="Miperf";;
            esac

            echo "" >> $log
            echo "Mesure $1 : $nom"
            echo "---------------------------------------------------------------" >> $log
            echo "Mesure $1 : $nom" >> $log
            echo "---------------------------------------------------------------" >> $log
            $mesure $log
        }
        for k in 1 2 3 4 5
        do
        boucle $k
        echo "" >> $log
        done
    }

    # Test sur le type de log pour lancer les instructions appropriées
    case $log in
        logping) Mping $log;;
        logftp) Mftp $log;;
        loghttp) Mhttp $log;;
        loghttpp) Mhttpp $log;;
        logiperf) Miperf $log;;
        logall) Mall $log;;
    esac        
}

# Libre choix : visualisation immédiate du log (ou non) 
function lire(){
    echo ""
    while test "$input" != [yYnN]
    do
        echo "Souhaitez-vous visualiser le fichier $log ? [y/n]"
        read input
        case "$input" in
            [yY])
            less $log
            echo "---------------------------------------------------------------"
            echo "Les résultats sont dans le fichier '$(pwd)/$log'"
            echo "---------------------------------------------------------------"
            exit 0;;
            
            [nN])
            echo "---------------------------------------------------------------"
            echo "Les résultats sont dans le fichier '$(pwd)/$log'"
            echo "---------------------------------------------------------------"
            exit 0;;
        esac
    done
}

# Gestion du menu de choix pour le type de mesures à effectuer
function menu(){
    clear
    echo "---------------------------------------------------------------"
    echo "|                   Choix du protocole de test                |"
    echo "---------------------------------------------------------------"
    echo "Appuyez sur une touche, puis validez. Touche [7] pour quitter."
    echo ""
    select j in  'PING' 'FTP' 'HTTP' 'HTTP+PROXY' 'IPERF' 'ALL' 'QUIT'
        do
            case $j in
                PING|FTP|HTTP|HTTP+PROXY|IPERF|ALL)
                mesure log$(echo $j|tr '[A-Z]' '[a-z]')
                echo "Mesures terminées. Bonne journée !"
                lire
                exit 0;;
        
                QUIT)
                clear
                echo "Script terminé. Bonne journée."
                exit 0;;
    
                *)
                echo "Veuillez entrer un chiffre entre 1 et 6. Merci."
                echo "Touche '7' pour quitter, 'ctrl+d' pour interrompre";;
            esac
    done 
}
menu

Merci,
Et bonne journée !

Anvil

    case $log in
        logping) Mping $log;;
        logftp) Mftp $log;;
        loghttp) Mhttp $log;;
        loghttpp) Mhttpp $log;;
        logiperf) Miperf $log;;
        logcomplet) Mcomplet $log;;
    esac

---> smarter :

M${log#log} $log

Temet

Tu peux expliquer le {log#log} please?

(ne me dis pas "man bash" ... j'ai pas de Linux en Italie ... c'est une question de curieux stou :p)

Anvil

ne me dis pas "man bash"

Ok. STFW ! http://dpobel.free.fr/man/html/affiche_man.php/105/man/bash/
Cherche ##

Temet

:-D

J'avais beaucoup hésité à poser la question ... j'aurais pas dû la poser!

D'un coté, je te dirais que

${paramètre#mot}
${paramètre##mot}
Le mot est développé pour fournir un motif, comme
dans l'expansion des noms de fichiers. Si le motif
correspond au debut de la valeur du paramètre,
alors le développement prend la valeur du paramètre
après suppression du plus petit motif commun (cas
``#''), ou du plus long motif (cas ``##'').

Bah j'ai pas compris! LOL
M'enfin c'est pas important, c'était juste par curiosité.

EDIT: ouais si c'est bon, j'ai capté... juste qu'avec mes compétences très limitées en bash j'aurais mis {$log#log} ... dsl

Anvil

Le mot est développé pour fournir un motif, comme dans l'expansion des noms de fichiers.

${paramètre##mot} <-> le "mot" peut etre un motif contenant des '*' '[x-y]' '?' et autres jokers du shell.

Si le motif ...

motif = mot expansé.

... correspond au debut de la valeur du paramètre,

facile ca.

alors le développement ...

de ${parametre##mot}

... prend la valeur du paramètre après suppression du plus petit motif commun (cas ``#'') ...

foo=abcbd ; echo ${foo#a*b} --> cbd

, ou du plus long motif (cas ``##'').

foo=abcbd ; echo ${foo##a*b} --> d

C'est pourtant simple !

Nawak

Ah, oui !

Effectivement, c'est plus intelligent. une ligne en lieu et place de 8, avec une rapidité d'éxécution forcément plus importante, y'a pas à dire... Le pire, c'est que je me suis dit à des endroits comme celui-ci : "je suis sûr qu'il y a moyen de simplifier", mais ne sachant pas comment...

Et le MAN, il est bien gentil, ça aide beaucoup, mais assez souvent, le language employé, du style - "j'en fais le moins possible, et si possible sans exemples ni explications" - n'aide pas suffisement, à moins d'avoir déjà de bonnes grosses connaissances en programmation.

Avec une certaine expérience, tout devient plus naturel, et on a tendance à perdre de vue que ce n'est pas si évident au premier abord...
😉

Finalement, je crois que je vais découper le script en 3 parties :
- tests ping (différentes tailles de paquets, QoS)
- tests iperf (différents paramètres sur le client)
- autres tests complémentaires

J'ai montré le travail, et j'ai zappé 2 autres aspects qu'ils utilisent souvent :
- partage SMB (partage windows)
- partage NCP (Novell Netware)
Comment puis-je tester les taux de transferts (en Kbits/sec si possible) sur ces 2 éléments ?

Merci.

Sat

Si tu cherches de la doc de qualité sur Bash avec des exemples :
http://www.tldp.org/LDP/Bash-Beginners-Guide/html/
http://www.tldp.org/LDP/abs/html/

Nawak

Merci pour les liens.

J'ai eu une idée pour mesurer les taux de transfert en SMB et NCP, mais je ne sais pas comment la mettre en forme. Je suis une quiche en math (filière communication). Mais voici mon raisonnement :

D'abord, je paramètre un client samba et un client ncp.

Ensuite, je crée un script :
1- je récupère un temps 1 (en secondes)
2- j'éxcute une copie d'un fichier (cp)
3- je récupère un temps 2 (en secondes)

Finalement, je dois réaliser une formule... soit :
T = temps 2 - temps 1
P = poids du fichier en MegaOctets(fixe, que je pourrais hard-coder)
rappel : 1 octet = 1 byte = 8 bits

Maintenant, comment faire pour récupérer un taux dont l'unité serait le Kilobit/seconde ?
Première étape, comment récupérer le timer sous forme de secondes via le script ?

Page suivante »