IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

Python Discussion :

Ping et multithread


Sujet :

Python

  1. #1
    Membre régulier
    Profil pro
    Inscrit en
    septembre 2008
    Messages
    99
    Détails du profil
    Informations personnelles :
    Localisation : France, Savoie (Rhône Alpes)

    Informations forums :
    Inscription : septembre 2008
    Messages : 99
    Points : 93
    Points
    93
    Par défaut 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 : 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"')

  2. #2
    Membre habitué
    Profil pro
    Inscrit en
    mai 2008
    Messages
    141
    Détails du profil
    Informations personnelles :
    Âge : 43
    Localisation : France, Paris (Île de France)

    Informations forums :
    Inscription : mai 2008
    Messages : 141
    Points : 184
    Points
    184
    Par défaut
    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"!

  3. #3
    Membre régulier
    Profil pro
    Inscrit en
    septembre 2008
    Messages
    99
    Détails du profil
    Informations personnelles :
    Localisation : France, Savoie (Rhône Alpes)

    Informations forums :
    Inscription : septembre 2008
    Messages : 99
    Points : 93
    Points
    93
    Par défaut
    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

  4. #4
    Membre régulier
    Profil pro
    Inscrit en
    septembre 2008
    Messages
    99
    Détails du profil
    Informations personnelles :
    Localisation : France, Savoie (Rhône Alpes)

    Informations forums :
    Inscription : septembre 2008
    Messages : 99
    Points : 93
    Points
    93
    Par défaut
    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

  5. #5
    Membre habitué
    Profil pro
    Inscrit en
    mai 2008
    Messages
    141
    Détails du profil
    Informations personnelles :
    Âge : 43
    Localisation : France, Paris (Île de France)

    Informations forums :
    Inscription : mai 2008
    Messages : 141
    Points : 184
    Points
    184
    Par défaut
    Salut!

    Citation Envoyé par BbT0n Voir le message
    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.

    Citation Envoyé par BbT0n Voir le message
    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.

  6. #6
    Expert confirmé
    Avatar de fred1599
    Homme Profil pro
    Développeur python
    Inscrit en
    juillet 2006
    Messages
    3 158
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Meurthe et Moselle (Lorraine)

    Informations professionnelles :
    Activité : Développeur python
    Secteur : Santé

    Informations forums :
    Inscription : juillet 2006
    Messages : 3 158
    Points : 5 930
    Points
    5 930
    Par défaut
    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 ?
    Celui qui trouve sans chercher est celui qui a longtemps cherché sans trouver.(Bachelard)
    La connaissance s'acquiert par l'expérience, tout le reste n'est que de l'information.(Einstein)

  7. #7
    Expert éminent sénior
    Homme Profil pro
    Architecte technique retraité
    Inscrit en
    juin 2008
    Messages
    18 377
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Manche (Basse Normandie)

    Informations professionnelles :
    Activité : Architecte technique retraité
    Secteur : Industrie

    Informations forums :
    Inscription : juin 2008
    Messages : 18 377
    Points : 31 782
    Points
    31 782
    Par défaut Codez votre ping 'à la main'!
    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
    Architectures post-modernes.
    Python sur DVP c'est aussi des FAQs, des cours et tutoriels

  8. #8
    Membre éclairé
    Profil pro
    Inscrit en
    août 2008
    Messages
    505
    Détails du profil
    Informations personnelles :
    Localisation : France, Puy de Dôme (Auvergne)

    Informations forums :
    Inscription : août 2008
    Messages : 505
    Points : 712
    Points
    712
    Par défaut
    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 : 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
     
    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)

  9. #9
    Membre régulier
    Profil pro
    Inscrit en
    septembre 2008
    Messages
    99
    Détails du profil
    Informations personnelles :
    Localisation : France, Savoie (Rhône Alpes)

    Informations forums :
    Inscription : septembre 2008
    Messages : 99
    Points : 93
    Points
    93
    Par défaut
    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
    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
    Dés que j'ai developpé la fonction qui va bien, je pose le code

    Bonne journée

  10. #10
    Membre régulier
    Profil pro
    Inscrit en
    septembre 2008
    Messages
    99
    Détails du profil
    Informations personnelles :
    Localisation : France, Savoie (Rhône Alpes)

    Informations forums :
    Inscription : septembre 2008
    Messages : 99
    Points : 93
    Points
    93
    Par défaut
    Hello,
    J'UP mon poste qui date un peut certes, mais je viens de reprendre ce programme que j'ai du laissé en suspens !

    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
    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 : Sélectionner tout - Visualiser dans une fenêtre à part
    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 : 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
     
     
    ##############################################
    # 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

  11. #11
    Expert confirmé Avatar de PauseKawa
    Homme Profil pro
    Technicien Help Desk, maintenance, réseau, système et +
    Inscrit en
    juin 2006
    Messages
    2 725
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Hérault (Languedoc Roussillon)

    Informations professionnelles :
    Activité : Technicien Help Desk, maintenance, réseau, système et +
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : juin 2006
    Messages : 2 725
    Points : 4 005
    Points
    4 005
    Par défaut
    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
    Merci d'utiliser le forum pour les questions techniques.

  12. #12
    Membre régulier
    Profil pro
    Inscrit en
    septembre 2008
    Messages
    99
    Détails du profil
    Informations personnelles :
    Localisation : France, Savoie (Rhône Alpes)

    Informations forums :
    Inscription : septembre 2008
    Messages : 99
    Points : 93
    Points
    93
    Par défaut
    Shame on me !

    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
    Est-il possible de mettre les module créée dans un répertoire, car à la racine du programme ça fait un peut sale

    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

Discussions similaires

  1. [Débutant] Ping Multithreading depuis un fichier Excel
    Par barbiche42 dans le forum VB.NET
    Réponses: 0
    Dernier message: 30/01/2012, 15h56
  2. Ping sous protocole TCP (et non UDP)
    Par ovdz dans le forum Développement
    Réponses: 2
    Dernier message: 19/06/2003, 14h10
  3. Ping de broadcast sous Windows
    Par ovh dans le forum Développement
    Réponses: 10
    Dernier message: 09/05/2003, 18h40
  4. ping sur un port
    Par Neo41 dans le forum Développement
    Réponses: 3
    Dernier message: 21/01/2003, 01h42
  5. Multithreading sous HP Ux 11
    Par pykoon dans le forum Autres éditeurs
    Réponses: 1
    Dernier message: 18/10/2002, 23h36

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo