Discussion :

[BbT0n]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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"')

[nardo47]

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"!

[BbT0n]

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

Je vais creser tout ça....

Il on l'air d'utiliser

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[BbT0n]

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

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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
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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

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

[nardo47]

Salut!

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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.

[fred1599]

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 ?