python + mesure débit LAN

[Jean-Michel <jeanmichel.123@free.fr>]

Je souhaite mesure le débit entre n machines (deux à deux) sur un réseau
LAN.


J'ai donc envisagé d'écrire un script python afin de

* mesurer le temps pris par le transfert

* pouvoir ajouter des fonctionnalités de mesure facilement


Je suis donc emmené à me poser les deux questions suivantes:

* Python ne risque t'il pas de par sa lenteur aléatoire due au garbage
collector de perturber les mesures?

* Est-il possible de lire des données sur un flux TCP, sans avoir à
créer un objet pour chaque paquet lu?


Le cas échéant, comment faire?


Pour info:


#--8<--------------------------------------8<-------------------------------

#!/usr/bin/python

import time
import socket
import SocketServer
import string


class Chronometre:
  def __init__(self):
    y=(1970, 1, 1, 1, 0, 0, 0, 0, 0)
    self.y=time.mktime(y)
  def restart(self):
    self.y = time.time()
  def get_value(self):
    x = time.time()
    resultat=x-self.y
    return resultat


class request_handler (SocketServer.StreamRequestHandler):
    def handle (self):
        print "handle"
        state = 0
        chrono = self.server.chrono
        million = 1024 * 1024
        v = 1
        while (1):
            if state == 0:
                   v = 1
            elif state == 1:
                   v = 5
            elif state == 2:
                   v = 50
            if state <= 2:
                commande =  'cmd=up' + str(v) + 'M'
                chrono.restart()
                self.wfile.write(commande)
                n = v * million
                r = n
                while (r>0):
                    d = self.rfile.read(1024)
                    r = r-len(d)
                delta = chrono.get_value()
                n_octets = n-r
                print "delta : ", delta , "...", n_octets
                Mo=million
                print "débit montant: ", n_octets / (Mo*delta ) , "Mo/s"
                print "                        ------>", 8 * n_octets /
(Mo*delta ) , "Mbits/s"
            state=state + 1
            if state > 2:
                 state=0
            print "Pause debut"
            time.sleep(2)
            print "Pause fin"
            #self.server.state = state
       
class tcp_server (SocketServer.ThreadingMixIn, SocketServer.TCPServer):
    def __init__(self,a,b):
      self.daemon_threads = 0
      self.chrono=Chronometre()
      self.state=0
      SocketServer.TCPServer.__init__(self,a,b)
      SocketServer.TCPServer.daemon_threads = 0

if __name__=="__main__":
    port=3700   
    hostname = socket.gethostname()
    ip_address = socket.gethostbyname(hostname)
    (hostname, aliaslist, ipaddrlist) = socket.gethostbyaddr(ip_address)
    for ip in ipaddrlist:
        print "détécté :" ,ip
    ip = ip_address
    print "Utilise :" , ip, port
    s = tcp_server ( (ip,port), request_handler )
    s.daemon_threads = 0
    s.serve_forever()
    print "Le serveur a été lancé"



#--8<--------------------------------------8<-------------------------------


#!/usr/bin/python

import socket
import re
#import unicode

port=3700
clisocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s=clisocket
s.connect(('127.0.0.1', port))

re_cmd_up = re.compile('cmd=up([0-9]*)M')
million = 1024 * 1024
while 1:
    s.send('')  # send test string
    data = s.recv(10)
    commande = unicode( data , 'utf-8')
    print commande
    n = 1
    m = re_cmd_up.match(commande)
    if m:
        n =  int(m.group(1))
        print m.group(1)
    buffer = 1024 * " "
    for i in range (0,n):
        print "i = " , i
        for j in range (0,1024):
             s.send(buffer) 
    print "close"

s.close()


#--8<--------------------------------------8<-------------------------------




--------------------------------------------------------------------
Les listes de diffusion occultes: <URL:http://www.CULTe.org/listes/>