Récupérer via une liste, le serveur le plus rapide

Version imprimable

Voir 40 message(s) de cette discussion en une page

Bonjour :)

Je tente de réaliser un script qui permet via une liste définie de serveurs de sélectionner celui qui est le plus rapide.
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 #!/bin/sh chosts="serveur1.com serveur2.org serveur3.fr" maverage="20000" cserver="" for hosts in $chosts do rping=`ping -c 3 $hosts | tail -1 | awk '{ print $4 }' | cut -d '/' -f 2` cserver=${rping} if [ "$cserver" -lt "$maverage" ]; then cserver=$hosts fi done echo $cserver
Si j'exécute la commande suivante:

Code:

ping -c 3 serveur1.com | tail -1 | awk '{ print $4 }' | cut -d '/' -f 2

j'obtiens bien un résultat comme: 7.793

Cependant, lorsque j'exécute le script en lui même, j'obtiens le résultat suivant:
Code:

1 2 3 4 5 test1[16]: 7.403: unexpected '.' test1[16]: 4.626: unexpected '.' test1[16]: 5.456: unexpected '.' 5.456
Un petit coup de main s'il vous plaît :mrgreen:

18/05/2018, 11h53
disedorgue

Bonjour,

Le souci ici est que le shell ne gère pas les nombre décimaux, d'où le souci du "." dans le test...

Il faut que tes valeurs soient des entiers.

Une solution, remplace ta ligne de ping par:

Code:

ping -c 3 localhost | awk -F\/ 'END{print $5*1000}'

Celle-ci fait la même chose mais multiplie par 1000 afin d'obtenir un entier.

Merci beaucoup pour cette explication.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#!/bin/sh
 
chosts="serveur1.com serveur2.org serveur3.fr"
 
maverage="20000"
cserver=""
mserv=""
 
for hosts in $chosts
do
   test1=`ping -c 3 $hosts | awk -F\/ 'END{print $5*1000}'`
   test2=${test1}
   if [ "$test2" -lt "$maverage" ]; then
       cserver=$hosts
       mserv=$test2
   fi
done
 
echo $mserv $cserver

Le script semble fonctionner mais c'est toujours le dernier serveur de la liste qui ressort même si j'en rajoute :aie:

18/05/2018, 12h41
disedorgue

C'est normal, tu compares chacun de tes serveur avec une valeur fixe maverage="20000"
18/05/2018, 13h07
Olivier Regnier

Citation:

Envoyé par disedorgue

C'est normal, tu compares chacun de tes serveur avec une valeur fixe maverage="20000"

Je ne vois pas comment je pourrai faire sans devoir fixer une valeur fixe minimale.
18/05/2018, 14h52
disedorgue

Oui, mais à un certain moment, il faut que la valeur de cette variable change, ce qui n'est pas le cas ici.

Ce que tu fait, c'est que tu compare tout tes serveurs avec cette valeur fixe et si celle du serveur est plus petite alors tu prends ce serveur, donc, à part si ton dernier serveur est plus grand que cette valeur, alors il gagnera tout le temps...
18/05/2018, 15h49
BufferBob
salut,

plutôt que de faire des comparaisons en cascade, d'une part on pourrait éventuellement s'en remettre à sort pour trier et ne conserver que la 1er/dernière ligne
mais on peut même faire plus simple et plus rapide, si on lance tous les pings en même temps, on considère que le premier qui revient est le plus rapide tout simplement
Code:

1 2 3 for serv in liste_machines; do { ping -c 3 "$serv" | awk -F'/' -vSERV="$serv" 'END {print $5 " " SERV}';} & done | head -1 | cut -d' ' -f2
18/05/2018, 17h06
disedorgue

Citation:

Envoyé par BufferBob

mais on peut même faire plus simple et plus rapide, si on lance tous les pings en même temps, on considère que le premier qui revient est le plus rapide tout simplement

Moi, sur disons 1000 serveurs, je ne sais pas lancer exactement en même temps les 1000 ping en espérant que ce soit le premier qui réponds qui est le plus rapide...
Rien que les chargement de contexte des commandes ping vont te créer de la latence qui fait que tu auras un ping qui aura répondu alors que le dernier n'aura même pas été lancé...
Dans un monde idéal, ta limite serait au mieux sur le nombre de core que tu as sur la machine qui lance les ping...

Pour le sort, on est d'accord, je pense même que le awk pourrait avantageusement le remplacer.
18/05/2018, 20h54
Olivier Regnier
Je vous remercie pour toutes vos explications. C'est plus clair.

J'ai une dernière question avant de clôturer ce Topic concernant le code qui m'a été proposé:
Code:

1 2 3 for serv in liste_machines; do { ping -c 3 "$serv" | awk -F'/' -vSERV="$serv" 'END {print $5 " " SERV}';} & done | head -1 | cut -d' ' -f2
Je souhaiterai récupérer ce résultat dans une variable afin de l'exporter comme suit:

Code:

export CVSROOT="anoncvs@$mavariable:/cvs

tout en gardant le code cité ci-dessus :oops:
18/05/2018, 21h12
disedorgue

Hmmm, dans mon post précédent, j'explique que ce code n'est pas fiable et je dis pourquoi...
18/05/2018, 22h09
Olivier Regnier

Citation:

Envoyé par disedorgue

Hmmm, dans mon post précédent, j'explique que ce code n'est pas fiable et je dis pourquoi...

:mouarf: désolé. Bon je vais me poser quelques secondes.

Bon, voici la correction possible de ton script (pas testé) :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#!/bin/sh
 
chosts="serveur1.com serveur2.org serveur3.fr"
 
cserver=""
mserv="20000"
 
for hosts in $chosts
do
   test1=`ping -c 3 $hosts | awk -F\/ 'END{print $5*1000}'`
   test2=${test1}
   if [ "$test2" -lt "$mserv" ]; then
       cserver=$hosts
       mserv=$test2
   fi
done
 
echo $mserv $cserver

Citation:

Envoyé par disedorgue

Moi, sur disons 1000 serveurs, je ne sais pas lancer exactement en même temps les 1000 ping en espérant que ce soit le premier qui réponds qui est le plus rapide...

ça fait beaucoup de serveurs :aie:

effectivement si on a un grand nombre de machines à tester vaut sans doute mieux oublier ping et bash et s'orienter vers un outil dédié comme fping par exemple ou en coder un vite fait à coups de Python/Scapy
sinon pour un nombre raisonnable de serveurs à tester (20, 30, 50...) le code que j'ai donné est à mon sens suffisant, sachant qu'un context switch une fois les pings lancés ne prend que quelques nanosecondes

ce qui est réellement gourmand c'est la création de processus (fork + exec de ping en gros), sur une machine un peu pourrie pour 1000 serveurs on atteint presque 1s de latence, s'il est question de tester un millier de machines toutes très réactives on est effectivement pas dans les clous, mais en pratique la différence de latence entre deux machines sur le réseau peut souvent être de l'ordre de la seconde, c'est donc pas complètement déconnant non plus

enfin s'il est question de lancer des ping -c3 j'aurai tendance à penser qu'on est dans le cas d'une petite liste de machines sur internet et pas d'un gros pool de serveurs avec une latence qui se joue à la microseconde près
dans tous les cas avec 3 itérations à chaque fois, le faire en séquentiel ça me semble assez peu avisé, à plus forte raison si on parle d'un millier de serveurs...
Code:

1 2 3 4 5 6 7 # time fping -qec3 www.google.com www.yahoo.com www.amazon.com www.kag gle.com www.google.com : xmt/rcv/%loss = 3/3/0%, min/avg/max = 5.05/5.08/5.12 www.yahoo.com : xmt/rcv/%loss = 3/3/0%, min/avg/max = 18.1/18.2/18.2 www.amazon.com : xmt/rcv/%loss = 3/3/0%, min/avg/max = 3.56/3.57/3.58 www.kag gle.com : xmt/rcv/%loss = 3/0/100% real 0m2.612s

Tout d'abord, un grand merci pour votre aide qui m'est précieuse.

Comme indiqué dans le message précédent, la commande fping serait la plus appropriée. En effet, j'ai effectué quelques tests et j'ai pondu un nouveau script:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
#!/bin/sh
 
echo ">> check cvs server - please wait..."
 
acsl="$(curl -s https://www.openbsd.org/anoncvs.html | grep -Eo "CVSROOT=.*" | sed 's/<[^>]*>//g' | awk -F'[@,:]' '{ print $2 }')"
 
if [ $? -eq 0 ]; then
    echo ">> cvs server list fetched."
else
    echo ">> unable to fetch cvs server list!"
fi
 
aacs=`fping -t 100 -a -e -q $acsl | awk '{ print $2,$1 }' | tr -d "(" | sort -n | head -5`
 
if [ $? -eq 0 ]; then
    echo ">> five top cvs server:\n"
    echo "$aacs\n"
else
    echo ">> unable to display the five top cvs server!"
fi
 
cacs=`echo $aacs | awk '{ print $2 }' | head -1`
 
echo ">> cvs server used: $cacs."
 
exit 0

le résultat:

Code:

1
2
3
4
5
6
7
8
9
10
11
>> check cvs server - please wait...
>> cvs server list fetched.
>> five top cvs server:
 
4.29 files.venture37.com
9.51 anoncvs@fr.openbsd.org
13.8 ftp.hostserver.de
17.6 anoncvs@spacehopper.org
27.1 mirror.osn.de
 
>> cvs server used: files.venture37.com.

Le script n'est pas parfait donc si vous avez des idées d'améliorations, je suis preneur :mrgreen:

19/05/2018, 15h29
BufferBob

Citation:

Envoyé par Olivier Regnier

Le script n'est pas parfait donc si vous avez des idées d'améliorations, je suis preneur :mrgreen:

rien de renversant, le test ligne 7 avec $? est bancal, dans la mesure où la dernière commande exécutée concrètement c'est awk et qu'à l'inverse de grep il retournera 0 par défaut, donc le test passera même si curl vautre
on peut aussi faire directement un curl (...) | grep -Po "CVSROOT=.+?@\K.+?(?=:.+)" par exemple, et ligne 13 un fping (...) | sed -r 's/(.+) $(.+) ms$/\2\t\1/' | sort -nk1 | head -5

J'ai modifié le script de la façon suivante:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
#!/bin/sh
cpkg="/usr/local/bin/curl"
gpkg="/usr/local/bin/ggrep"
fpkg="/usr/local/bin/fping"
urll="https://www.openbsd.org/anoncvs.html"
 
for pkgs in "$cpkg" "gpkg" "$fpkg"; do
    if [ ! -x "$pkgs" ]; then
        echo ">> curl, ggrep and fping programs are required!"
        exit 1
    fi
done
 
echo ">> Fetching CVS servers list. Please wait."
 
gcvs=`curl -s "$urll" | ggrep -Po "CVSROOT=.+?@\K.+?(?=:.+)"`
acvs=`fping -t 100 -aeq $gcvs | sed -r 's/(.+) \ ((.+) ms\)/\2\ \1/' | sort -nk1`
ncvs=`echo "$acvs" | wc -l | sed 's/^ *//g'`
ccvs=`echo "$acvs" | awk '{ print $2 }' | head -1`
 
if [ $? -eq 0 ]; then
    echo ">> Available CVS servers: $ncvs."
    echo "$acvs | awk '{ print $1,$2 }' | cat -n
    echo ">> Current fatest CVS server: $ccvs."
else
    echo ">> Unable to fetch CVS servers list!"
fi
 
exit 0

Le résultat est le suivant:

Code:

1
2
3
4
5
6
7
8
9
10
>> Fetching CVS servers lists. Please wait.
>> Available CVS servers: 17.
        1   4.13 files.venture37.com
        2   5.82 anoncvs.fr.openbsd.org
        3   13.9 ftp.hostserver.de
        4   19.1 anoncvs.spacehopper.org
        5   25.3 mirror.osn.de
        6   34.4 anoncvs.obsd.si
        ...
>> Current fatest CVS server: files.venture37.com.

Pour toutes améliorations, je suis preneur.

Mon objectif est atteint car ce qui m'intéresse c'est d'obtenir le nombre de serveurs disponibles et celui qui semble être le plus rapide. Le détail relatif aux 17 serveurs comme dans l'exemple est un plus mais pas indispensable.

Maintenant s'il était, l'affichage suivant aurait été intéressant:

Code:

1
2
3
4
5
6
7
8
9
10
11
>> Fetching CVS servers lists. Please wait.
>> Available CVS servers: 17.
  01 (4.13 ms) - files.venture37.com
  02 (5.82 ms) - anoncvs.fr.openbsd.org
  03 (13.9 ms) - ftp.hostserver.de
  04 (19.1 ms) - anoncvs.spacehopper.org
  05 (25.3 ms) - mirror.osn.de
  06 (34.4 ms) - anoncvs.obsd.si
  07 (100 ms)  - anoncvs.example.org
       ...
>> Current fatest CVS server: files.venture37.com.

Mais la gestion des tabulations est loin d'être évidente :aie:

21/05/2018, 08h54
BufferBob
Citation:

Envoyé par Olivier Regnier

J'ai modifié le script (...)

Code:

gcvs=`curl -s "$urll" | ggrep -Po "CVSROOT=.+?@\K.+?(?=:.+)"`

au temps pour moi en fait, j'avais zappé qu'on était dans la section Unix/POSIX, après si t'as trouvé ton bonheur avec ggrep tant mieux
Citation:
Envoyé par Olivier Regnier

l'affichage suivant aurait été intéressant:

Code:

1 2 3 4 (...) 05 (25.3 ms) - mirror.osn.de 06 (34.4 ms) - anoncvs.obsd.si 07 (100 ms) - anoncvs.example.org

Mais la gestion des tabulations est loin d'être évidente :aie:
avec printf, en jouant sur la chaine de format :
Code:

1 2 3 4 $ for i in 25.3 34.4 100; do ((count++)); printf " %02d %-9s - server%d.com\n" $count "($i ms)" $count; done 01 (25.3 ms) - server1.com 02 (34.4 ms) - server2.com 03 (100 ms) - server3.com

Citation:

Envoyé par BufferBob

avec printf, en jouant sur la chaine de format :

Code:

1
2
3
4
$ for i in 25.3 34.4 100; do ((count++)); printf "  %02d %-9s - server%d.com\n" $count "($i ms)" $count; done
  01 (25.3 ms) - server1.com
  02 (34.4 ms) - server2.com
  03 (100 ms)  - server3.com

Je comprends le code (ci-dessus),

Code:

1
2
3
 
acvs=`fping -t 100 -aeq $gcvs | sed -r 's/(.+)  \((.+) ms\)/\2\  \1/' | sort -nk1`
for i in "$acvs"; do ((count++)); printf " %02d %-9s - $2\n" $count "($i ms)"; $count; done

mais je ne parviens pas à dissocier $1 et $2 de la variable $acvs avec printf et donc le résultat qui est normal est le suivant:

Code:

1
2
3
4
5
01 (4.21 files.venture37.com
7.96 anoncvs.fr.openbsd.org
...
294 anoncvs.au.openbsd.org ms)
ksh: 1: not found

21/05/2018, 12h14
Flodelarab

Bonjour :coucou:

printf utilise une chaîne de formatage, puis une liste de données.
%d ou %i pour un nombre entier.
%s pour une chaîne de caractère.
%02d pour un entier de 2 chiffres. Le cas échéant, ajouter des 0 non significatifs.
%9s pour une chaîne de caractère d'au moins taille 9. Le cas échéant, ajouter des espaces.
%-9s pour une chaîne de caractère d'au moins taille 9. Le cas échéant, ajouter des espaces. Justifier de l'autre côté.

Citation:

Mais la gestion des tabulations est loin d'être évidente

Il n'y a pas de tabulations. On réserve la place suffisante pour les chaînes de caractères afin d'avoir un alignement parfait.
Sinon, il suffirait de mettre \t dans le printf.

Citation:

Code:

printf " %02d %-9s - $2

Que vient faire $2 dans la chaîne de formatage ?
Comme sa taille n'est pas connue à l'avance, il semblerait plus judicieux de le mettre dans la liste des données et mettre "%s" dans la format.
$2 désigne ici le deuxième argument de ton script. Est-ce vraiment de que tu veux ?

Citation:

Code:

ms)";

Point-virgule. Donc la commande printf est finie.

Citation:

Code:

$count;

Et tu essaie d'exécuter le compteur... évidemment, cela ne marche pas: "ksh: 1: not found"
"1" n'est pas une commande.

Citation:

mais je ne parviens pas à dissocier $1 et $2 de la variable $acvs

N'y étais-tu pas arrivé dans la variable que tu appelais "ccvs" ?

J'ai réalisé un test:

Code:

1
2
3
4
5
6
avg=`echo "$acvs | awk '{ print $1 }'`
 
for i in "$avg"; do
    ((count++))
    printf "%02d %-9s\n" $count "($i ms)" $count
done

J'obtiens:

Code:

1
2
3
4
5
6
01 (4.00
5.78
14.7
...
294 ms)
01

:oops:

Voir 40 message(s) de cette discussion en une page