Ping et multithread

Bonjours à tous !

Je suis confronté à un problème, je dois faire des ping sur 1500 machine qui sont renseigné dans une liste.
Jusqu'a là pas de problème, j'arrive à le faire avec la fonction "os.system", sauf que cette méthode est valable pour quelque machine, car les ping sont séquentiel

Mon but serait que, de lancé un ping tout les 20 machine, en parallèle.
Par exemple:
ping1 ==> 20 premiére machine
ping2 ==> 20 machine suivante

1500/20 donc 75ping simultané

Donc ma question est:
Comment permettre des ping parallèle sans bloquer le programme principal?
Serait t-il plus sage d'utiliser une fonction ping intégré dans un module python ?

Voici, comment je fait mes ping actuellement.

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14

for i in liste_complete : ip = "ping -n 3 " + i[0] p = os.system(ip)   if (p == 0 ): #print "ping OK" ok += 1 i.append('"1"')   else: #print "ping NOK" nok += 1 i.append('"0"')

---

:merci:

Salut !

Twisted permet d'utiliser les threads. Genre, par ici.
Je ne connais pas (encore) bien Twisted, mais j'ai pu faire quelquechose avec cette page.

Après, le package threading doit pouvoir aider, mais je laisse la parole à des gens qui l'ont déjà utilisé !
Et peut-être que sortir Twisted pour résoudre ce problème, c'est comme d'enfoncer un clou avec un marteau-piqueur, mais bon.

Ah ! Et regarde le premier résultat de la recherche G**gle (pas de pub !) avec les mots "threading python tuto"! ;)

Intéressant, le premier lien sur lequel je tombe, cela semble être tout à fait ce que je veut faire, des pings avec des thread :mouarf:

Je vais creser tout ça....

Il on l'air d'utiliser

Code:

---

from threading import Thread

---

Pour twested, vraiment très intéressant, mais je l'implémenterais si j'ai un plus grand nombre de poste à ping, et dans tout les cas, même si je l'utilise, il me faudra employer les threads ...

Quand j'ai résolu le problème je pose le code :zoubi:

Bon alors, c'est super cool, les thread ça dépote :mouarf:

J'arrive à faire mes ping en parallelle voici le code, il me reste un dernier problémé pour finaliser la beta de mon programme, la fonction pour gérer les thread des ping.

Voici le code avec ma fonction ping et comment elle est appelé par les thread.

Donc, "liste_complete" contiens les nom de mes 1000machines, "debut" et "fin" la plage des machine qui serons ping (par ex: entre la machine 20 et 50)
Suivant l'etat du ping, il me rajoute dans la liste, l'etat du ping pour la machine en question

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

############################################## # fonction ping ##############################################   def ping(debut,fin,liste_complete): for liste in liste_complete[debut:fin]: ip = "ping -n 2 " + liste[0] p = os.system(ip)   if (p == 0 ): #print "ping OK" liste.append('1')   else: #print "ping NOK" liste.append('0')   time.sleep(0.01)   return

---

CA c'est la partis simple
Voci comment je les implemente dans les thread

Je creer le thread "a" lui passe ping comme fonction appelé et ensuite, les argument de la fonction ping
Ensuite je l'instancie (je croie que l'on dit comme ça) avec la methode start() et la methode join() je sais plus trop mais il faut la mettre.

Code:

---

1 2 3 4 5 6 7 8 9

a = threading.Thread(None, ping, None, (0,25,liste_complete,1)) b = threading.Thread(None, ping, None, (25,50,liste_complete,2))   a.start() b.start()   a.join() b.join()

---

Sauf que si je veut aller jusqu'a 1000 machine il y aura du copier/coller à ce niveau, ce qui n'est pas très pro :aie:
J'aimerais créer une fonction qui va bien, sauf que c'est une fonction (ping) dans une fonction (thread) et je n'arrive pas à mes fin,

Voci ce que j'ai deja fait:

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 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47

############################################## # Fonction qui creer les thread des ping ##############################################   def gen_thread(liste,nbr_thread): #!!!!!!!Partis ou je lutte !!!!!!!!! #def creer_thread(a,b,liste,nom_thread): # nom_thread = threading.Thread(None, ping, None, (a,b,liste,1)) # nom_thread.start() # nom_thread.join() #return   nbr_element_liste = 0 nbr_element_thread = 0 total = 0   #Nombre d'élement que contien la liste (nom de toute les machine) for i in liste: nbr_element_liste = nbr_element_liste + 1 print "nbr_element_liste = ", nbr_element_liste   #Permet de donner le pas pour chaque thread ecart = nbr_element_liste / nbr_thread   #Generation du tableau, ecart en fonction du nombre de thread tableau = range(0,nbr_element_liste,ecart)   for y in tableau: nbr_element_thread = nbr_element_thread + 1 print "nbr_element_thread =",nbr_element_thread tableau.append(nbr_element_liste)   print "tableau = ",tableau   a = 0 b = 1     for g in range(nbr_thread): print "a",tableau[a] print "b",tableau[b] a = a + 1 b = b + 1 #creer_thread(a,b,liste,'thread' + str(g))   return

---

Ca fonctionne plutot pas mal, voci ce que ça me retourne

Code:

---

1 2 3 4 5 6 7 8 9 10

nbr_element_liste = 1421 nbr_element_thread = 4 tableau = [0, 473, 946, 1419, 1421] a 0 b 473 a 473 b 946 a 946 b 1419

---

Il me reste à fusionner les deux ping et thread :calim2:

Si vous avez des sugestions ou autre.
Merci d'avance

Salut!

Citation:

---

Envoyé par BbT0n

Je creer le thread "a" lui passe ping comme fonction appelé et ensuite, les argument de la fonction ping
Ensuite je l'instancie (je croie que l'on dit comme ça) avec la methode start() et la methode join() je sais plus trop mais il faut la mettre.

Code:

---

1 2 3 4

a = threading.Thread(None, ping, None, (0,25,liste_complete,1)) a.start() a.join()

---

---

La ligne "a = threading.Thread(...)" est l'instanciation : tu crées une instance de Thread et tu la références par la variable "a".
Avec la méthode start, je dirais plutôt que tu inities/démarres le thread.
Pour la méthode join, je laisse parler ceux qui savent... ^^

----

Aucun problème en Python pour faire une fonction dans une fonction.

Citation:

---

Envoyé par BbT0n

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12

############################################## # Fonction qui creer les thread des ping ##############################################   def gen_thread(liste,nbr_thread): #!!!!!!!Partis ou je lutte !!!!!!!!! #def creer_thread(a,b,liste,nom_thread): # nom_thread = threading.Thread(None, ping, None, (a,b,liste,1)) # nom_thread.start() # nom_thread.join() #return

---

---

Ton return, ici, indique la fin de la fonction gen_thread, et non pas de la fonction creer_thread.
Si ta fonction ne renvoie aucun résultat, pas la peine d'écrire un return, Python verra tout seul que ta fonction est finie avec le niveau d'indentation.

Essaie déjà ça (bien qu'à mon avis, Python aurait du lever une IndentationError).

Pour le reste, je t'invite à :
1. regarder la fonction len ;
2. étudier ce bout de code :

Code:

---

1 2 3

for a, b in zip(tableau[:-1], tableau[1:]): print 'a', a, '- b', b

---

3. repenser ta fonction ping pour qu'elle ne modifie pas la liste qui lui est donnée en entrée, mais renvoie un résultat. Elle ne devrait pas non plus recevoir une liste complète, mais juste la liste des adresses à pinger.
Charge à l'appelant de traiter la liste lors de l'appel à ping et lorsque cette dernière renvoie le résultat.

Ton code fonctionnait avec os.system, si j'ai bien cru comprendre.

Ton problème est de laisser la main au programme principal ?

Si oui pourquoi ne pas utiliser plutôt la méthode Popen de subprocess, qui laisse lui justement la main au programme principal ?

Ping est un packet ICMP que le destinataire est supposé vous renvoyer tel que.
Vous pouvez donc utiliser les datas du packet pour indexer les réponses attendues et envoyer autant de packets que permet le raisonnable (interface réseau).
Vous avez à priori 3 threads:
1 - émettre,
2 - gérer les timeout et réemettre
3 - traiter les réponses.
Pour ce qui est du code jeter un oeil à fping, c'est du code C qui contient les algo de base.
Bon courage
- W

Je m'étais posé un problème assez similaire, je crois. J'avais trouvé un bout de code qui allait bien

Ca lance 5 threads en même temps, qui se contente d'attendre un nombre aléatoire de secondes (entre 1 et 10). 100 fois. Ca doit être très facilement adaptable au problème, si je ne m'abuse.

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

import threading from random import uniform from time import sleep   def affiche(nom): print "Debut du thread ", nom timesleep=uniform(1,10) sleep(timesleep) print "Fin du thread ",nom," apres ",timesleep     if __name__ == '__main__': ''' Initialize the loop ''' for i in range(5): threading.Thread(None, affiche, None,(i,),{}).start() nb=100 while(nb>0): if(threading.activeCount()<5): threading.Thread(None, affiche, None, (100-nb+5,) ,{}).start() nb=nb-1 sleep(2)

---

Merci à tous pour vos conseil !

@nardo47, je vais etudier ton bout de code, et voir comment mettre en place le point 3 de ta réponse.

@fred1599 Popen de subprocess, je connaissait pas, thx

Euhh non c'est pas ça :lol:

Citation:

---

Vous avez à priori 3 threads:
1 - émettre,
2 - gérer les timeout et réemettre
3 - traiter les réponses.

---

@thierry.chich, je vais regarder dans cette direction, je pense que mon problème viens de la gestion de mes fonction.

Je me suis retrouver à faire du gros copier coller, et c'est pas trés propre, mais ça marche :aie:
Dés que j'ai developpé la fonction qui va bien, je pose le code

Bonne journée :merci:

Hello,
J'UP mon poste qui date un peut certes, mais je viens de reprendre ce programme que j'ai du laissé en suspens ! :mouarf:

Ce matin après avoir repris mon code, je me suis rendu compte que c'était le fouilli! Toute mes fonction était ....... dans le même fichier :aie:
Ouioui je sais ça fait très pro. Donc première étape, réorganiser tout ça, et faire des module avec mes fonction.

Tout les fonction que j'ai mis dans des modules ce charge bien quand je les appel, mais le problème ce pose pour la fonction thread des ping que j'ai mis dans un module
IDLE me retourne

Code:

---

1 2 3 4 5 6 7 8

Traceback (most recent call last): File "X:\beta2\script_ping_b1_light.py", line 38, in <module> thread(liste_complete)   File "X:\beta2\ping.py", line 29, in thread a = threading.Thread(None, ping, None, (0,102,liste,1)) NameError: global name 'threading' is not defined

---

Voici mon code dans le module ping.py

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

############################################## # Creation de thread, un pour chaque ping ##############################################   def thread(liste): threading = None a = threading.Thread(None, ping, None, (0,102,liste,1)) b = threading.Thread(None, ping, None, (102,204,liste,2))   a.start() b.start()   a.join() b.join()

---

En revanche cela fonctionne quand je n'éclate pas mes fonctions en modules

Merci pour votre lumière :ccool:

Bonjour,

C'est tes imports. Mets ton import threading dans ping.py.

Sinon pour ce qui est du os.system/subprocess pourquoi ne pas passer par socket ?

@+

Edit : A la base

Shame on me ! :sm:

Merci pour tes éclaircissement, en faite j'importais dans mon fichier principal et dans mes module, et ça me faisait planter mon interpréteur !!
Donc ce qui est chargé dans un module n'a pas besoin de l'être dans le main :aie:
Est-il possible de mettre les module créée dans un répertoire, car à la racine du programme ça fait un peut sale :P

Citation:

---

Sinon pour ce qui est du os.system/subprocess pourquoi ne pas passer par socket ?

---

C'est ce que je pense faire par la suite, car je peut pas me permettre de faire 20 ping en parallèle avec la fonction ping du système, c'est bien trop lourd.
Mais étant donné que ça marche pour l'instant je le garde pour optimisation.

Comme tu voit pour ma fonction thread, les lettres vont en fait jusqu'à "t", et j'avais tenté à l'époque d'optimiser cette fonction.
J'avais trouvé l'algorithme, mais en python il me faisait une vielle erreur.
Quand j'aurai repris l'optimisation de cette partie, je ferai un UP sur ce post, car le problème était vraiment curieux.

thx a lot PauseKawa :ccool: