Example #1
0
  def test2node(self, test):
    xml = self._xml

    t = xml.createElement('test')
    t.setAttribute('type', str(test.type))

    time = xml.createElement('time')

    start = xml.createElement('start')
    start.appendChild(xml.createTextNode(str(test.start.isoformat())))
    time.appendChild(start)

    end = xml.createElement('end')
    end.appendChild(xml.createTextNode(str(datetime.fromtimestamp(timestampNtp()).isoformat())))
    time.appendChild(end)

    t.appendChild(time)

    value = xml.createElement('value')
    value.appendChild(xml.createTextNode(str(test.value)))
    t.appendChild(value)

    bytes = xml.createElement('byte')
    bytes.appendChild(xml.createTextNode(str(test.bytes)))
    t.appendChild(bytes)

    error = test.errorcode
    if (error != None):
      errorcode = xml.createElement('errcode')
      errorcode.appendChild(xml.createTextNode(str(error)))
      t.appendChild(errorcode)

    return t
Example #2
0
    def test2node(self, test):
        xml = self._xml

        t = xml.createElement('test')
        t.setAttribute('type', str(test.type))

        time = xml.createElement('time')

        start = xml.createElement('start')
        start.appendChild(xml.createTextNode(str(test.start.isoformat())))
        time.appendChild(start)

        end = xml.createElement('end')
        end.appendChild(
            xml.createTextNode(
                str(datetime.fromtimestamp(timestampNtp()).isoformat())))
        time.appendChild(end)

        t.appendChild(time)

        value = xml.createElement('value')
        value.appendChild(xml.createTextNode(str(test.value)))
        t.appendChild(value)

        bytes = xml.createElement('byte')
        bytes.appendChild(xml.createTextNode(str(test.bytes)))
        t.appendChild(bytes)

        error = test.errorcode
        if (error != None):
            errorcode = xml.createElement('errcode')
            errorcode.appendChild(xml.createTextNode(str(error)))
            t.appendChild(errorcode)

        return t
Example #3
0
  def testftpup(self, bytes, path):
    global ftp, file, size, filepath
    filepath = path
    test_type = 'upload'
    size = 0
    elapsed = 0

    file = Fakefile(bytes)
    timeout = max(self._timeout, 12)
    start = datetime.fromtimestamp(timestampNtp())

    try:
      ftp = FTP(self._host.ip, self._username, self._password, timeout=timeout)
    except ftplib.all_errors as e:
      errorcode = errors.geterrorcode(e)
      error = '[%s] Impossibile aprire la connessione FTP: %s' % (errorcode, e)
      logger.error(error)
      raise Exception(error)

    # TODO Se la connessione FTP viene invocata con timeout, il socket è non-blocking e il sistema può terminare i buffer di rete: http://bugs.python.org/issue8493
    function = '''ftp.storbinary('STOR %s' % filepath, file, callback=totalsize)'''
    setup = 'from %s import file, ftp, totalsize, filepath' % __name__
    timer = timeit.Timer(function, setup)

    try:
      logger.debug('Test initializing...')
      start_total_bytes = self._netstat.get_tx_bytes()

      logger.debug('Testing... ')
#       pcapper.sniff(Contabyte(self._if_ip, self._host.ip))

      # Il risultato deve essere espresso in millisecondi
      elapsed = timer.timeit(1) * 1000

#       pcapper.stop_sniff()
#       counter_stats = pcapper.get_stats()

      logger.debug('Test stopping... ')
      end_total_bytes = self._netstat.get_tx_bytes()
      logger.debug('Test done!')

    except ftplib.all_errors as e:
      errorcode = errors.geterrorcode(e)
      error = '[%s] Impossibile effettuare il test %s: %s' % (errorcode, test_type, e)
      logger.error(error)
      raise Exception(error)

    except Exception as e:
      errorcode = errors.geterrorcode(e)
      error = '[%s] Errore durante la misura %s: %s' % (errorcode, test_type, e)
      logger.error(error)
      raise Exception(error)

    ftp.quit()

    ''' TODO: get packet drop from netstat '''
    counter_stats = Statistics(byte_up_nem = size, byte_up_all = end_total_bytes - start_total_bytes, packet_drop = 0, packet_tot_all = 100)
#     return Proof(test_type, start, elapsed, size, counter_stats)
    return Proof(test_type, start, elapsed, size, counter_stats)
Example #4
0
  def onair(self):
    '''
    Restituisce true se non sono trascorsi ancora MAX_DAYS dallo start delle misure
    '''
    start = self.start()
    delta = datetime.fromtimestamp(timestampNtp()) - start
    if (delta.days > MAX_DAYS):
      return False

    return True
Example #5
0
 def _hourisdone(self):
   if not self._isprobe:
     now = datetime.fromtimestamp(timestampNtp())
     hour = now.hour
     made = self._progress.howmany(hour)
     if made >= MAX_MEASURES_PER_HOUR:
       return True
     else:
       return False
   else:
     return False
Example #6
0
  def testftpdown(self, filename):
    global ftp, file, size
    test_type = 'download'
    size = 0
    elapsed = 0

    file = filename
    timeout = max(self._timeout, 12)
    start = datetime.fromtimestamp(timestampNtp())

    try:
      ftp = FTP(self._host.ip, self._username, self._password, timeout=timeout)
    except ftplib.all_errors as e:
      errorcode = errors.geterrorcode(e)
      error = '[%s] Impossibile aprire la connessione FTP: %s' % (errorcode, e)
      logger.error(error)
      raise Exception(error)

    function = '''ftp.retrbinary('RETR %s' % file, totalsize)'''
    setup = 'from %s import ftp, file, totalsize' % __name__
    timer = timeit.Timer(function, setup)

    try:
      logger.debug('Test initializing...')
      start_total_bytes = self._netstat.get_rx_bytes()
      logger.debug('Testing... ')

      # Il risultato deve essere espresso in millisecondi
      elapsed = timer.timeit(1) * 1000

      logger.debug('Test stopping... ')
      end_total_bytes = self._netstat.get_rx_bytes()

      logger.debug('Test done!')

    except ftplib.all_errors as e:
      errorcode = errors.geterrorcode(e)
      error = '[%s] Impossibile effettuare il test %s: %s' % (errorcode, test_type, e)
      logger.error(error)
      raise Exception(error)

    except Exception as e:
      errorcode = errors.geterrorcode(e)
      error = '[%s] Errore durante la misura %s: %s' % (errorcode, test_type, e)
      logger.error(error)
      raise Exception(error)

    ftp.quit()

    ''' TODO: get packet drop from netstat '''
    counter_stats = Statistics(byte_down_nem = size, byte_down_all = end_total_bytes - start_total_bytes, packet_drop = 0, packet_tot_all = 100)
    return Proof(test_type, start, elapsed, size, counter_stats)
Example #7
0
def getfinishedtime(filename):
  '''
  Ricava il tempo di chiusura da un file di misura
  '''
  try:
    pattern = '[\dT\-:\.]*'
    # TODO Migliorare riferimenti a [finished] vedi executer.
    comment = '[finished]'
    time = iso2datetime(getcommentvalue(filename, comment, pattern))
  except Exception as e:
    logger.error('Errore durante il recupero del valore finished della misura: %s' % e)
    time=datetime.fromtimestamp(timestampNtp())    
  return time
Example #8
0
  def _newxml(self):
    logger.debug('Creo il file dello stato delle misure.')
    xml = parseString('<measure />')
    measure = xml.getElementsByTagName('measure')[0]

    start = xml.createElement('start')
    start.appendChild(xml.createTextNode(datetime.fromtimestamp(timestampNtp()).isoformat()))
    measure.appendChild(start)

    content = xml.createElement('content')
    measure.appendChild(content)

    return xml
Example #9
0
 def __init__(self, id, server, client, version=None, start=datetime.fromtimestamp(timestampNtp()).isoformat()):  
   '''
   Costruisce un oggetto Measure utilizzando i parametri ricevuti nella
   chiamata.
   Istanzia un oggetto XML in cui vengono salvati i test che costituiscono
   la misura. L'id della misura viene postposto all'id del client per generare
   l'id del file di misura XML.
   '''
   self._id = id
   self._server = server
   self._client = client
   self._version = version
   self._start = start
   self._xml = self.getxml()
Example #10
0
def getfinishedtime(filename):
    '''
  Ricava il tempo di chiusura da un file di misura
  '''
    try:
        pattern = '[\dT\-:\.]*'
        # TODO Migliorare riferimenti a [finished] vedi executer.
        comment = '[finished]'
        time = iso2datetime(getcommentvalue(filename, comment, pattern))
    except Exception as e:
        logger.error(
            'Errore durante il recupero del valore finished della misura: %s' %
            e)
        time = datetime.fromtimestamp(timestampNtp())
    return time
Example #11
0
    def pack(self, filename):
        '''
    Crea un file zip contenente //filename// e la sua firma SHA1.
    Restituisce il nome del file zip creato.
    '''

        # Aggiungi la data di invio in fondo al file
        with open(filename, 'a') as file:
            file.write(
                '\n<!-- [packed] %s -->' %
                datetime.datetime.fromtimestamp(timestampNtp()).isoformat())

        # Gestione della firma del file
        sign = None
        if self._certificate != None and path.exists(self._certificate):
            # Crea il file della firma
            signature = self.sign(filename)
            if signature == None:
                logger.error(
                    'Impossibile eseguire la firma del file delle misure. Creazione dello zip omettendo il .sign'
                )
            else:
                with open('%s.sign' % filename[0:-4], 'wb') as sign:
                    sign.write(signature)

        # Creazione del file zip
        zipname = '%s.zip' % filename[0:-4]
        zip = zipfile.ZipFile(zipname, 'a', zipfile.ZIP_DEFLATED)
        zip.write(file.name, path.basename(file.name))

        # Sposto la firma nello zip
        if sign != None and path.exists(sign.name):
            zip.write(sign.name, path.basename(sign.name))
            os.remove(sign.name)

        # Controllo lo zip
        if zip.testzip() != None:
            zip.close()
            logger.error("Lo zip %s è corrotto. Lo elimino." % zipname)
            os.remove(zipname)
            zipname = None
        else:
            zip.close()
            logger.debug("File %s compresso correttamente in %s" %
                         (filename, zipname))

        # A questo punto ho un xml e uno zip
        return zipname
Example #12
0
 def __init__(self,
              id,
              server,
              client,
              version=None,
              start=datetime.fromtimestamp(timestampNtp()).isoformat()):
     '''
 Costruisce un oggetto Measure utilizzando i parametri ricevuti nella
 chiamata.
 Istanzia un oggetto XML in cui vengono salvati i test che costituiscono
 la misura. L'id della misura viene postposto all'id del client per generare
 l'id del file di misura XML.
 '''
     self._id = id
     self._server = server
     self._client = client
     self._version = version
     self._start = start
     self._xml = self.getxml()
Example #13
0
  def pack(self, filename):
    '''
    Crea un file zip contenente //filename// e la sua firma SHA1.
    Restituisce il nome del file zip creato.
    '''

    # Aggiungi la data di invio in fondo al file
    with open(filename, 'a') as file:
      file.write('\n<!-- [packed] %s -->' % datetime.datetime.fromtimestamp(timestampNtp()).isoformat())      

    # Gestione della firma del file
    sign = None
    if self._certificate != None and path.exists(self._certificate):
      # Crea il file della firma
      signature = self.sign(filename)
      if signature == None:
        logger.error('Impossibile eseguire la firma del file delle misure. Creazione dello zip omettendo il .sign')
      else:
        with open('%s.sign' % filename[0:-4], 'wb') as sign:
          sign.write(signature)

    # Creazione del file zip
    zipname = '%s.zip' % filename[0:-4]
    zip = zipfile.ZipFile(zipname, 'a', zipfile.ZIP_DEFLATED)
    zip.write(file.name, path.basename(file.name))

    # Sposto la firma nello zip
    if sign != None and path.exists(sign.name):
        zip.write(sign.name, path.basename(sign.name))
        os.remove(sign.name)

    # Controllo lo zip
    if zip.testzip() != None:
      zip.close()
      logger.error("Lo zip %s è corrotto. Lo elimino." % zipname)
      os.remove(zipname)
      zipname = None
    else:
      zip.close()
      logger.debug("File %s compresso correttamente in %s" % (filename, zipname))

    # A questo punto ho un xml e uno zip
    return zipname
Example #14
0
  def testping(self):
    # si utilizza funzione ping.py
    test_type = 'ping'
    start = datetime.fromtimestamp(timestampNtp())
    elapsed = 0

    try:
      # Il risultato deve essere espresso in millisecondi
      elapsed = ping.do_one(self._host.ip, self._timeout) * 1000

    except Exception as e:
      errorcode = errors.geterrorcode(e)
      error = '[%s] Errore durante la misura %s: %s' % (errorcode, test_type, e)
      logger.error(error)
      raise Exception(error)

    if (elapsed == None):
      elapsed = 0

    return Proof(test_type, start = start, value = elapsed, bytes = 0)
Example #15
0
  def wait(self):

    # Se non è una sonda, ma un client d'utente
    if not self._isprobe:
      # Se ho fatto 2 misure in questa ora, aspetto la prossima ora
      now = datetime.fromtimestamp(timestampNtp())
      hour = now.hour
      made = self._progress.howmany(hour)
      if made >= MAX_MEASURES_PER_HOUR:

        # Quanti secondi perché scatti la prossima ora?
        wait_hour = self._polling
        try:
          delta_hour = now.replace(hour = (hour + 1) % 24, minute = 0, second = 0) - now
          if delta_hour.days < 0:
            logger.info('Nuovo giorno: delta_hour %s' % delta_hour)
          # Aggiungo un random di 5 minuti per evitare chiamate sincrone
          wait_hour = delta_hour.seconds
        except ValueError as e:
          logger.warning('Errore nella determinazione della prossima ora: %s.' % e)

        random_sleep = randint(2, self._polling * 15 / MAX_MEASURES_PER_HOUR)
        logger.info('La misura delle %d è completa. Aspetto %d secondi per il prossimo polling.' % (hour, wait_hour + random_sleep))

        # Aspetto un'ora poi aggiorno lo stato
        sleep(wait_hour)
        self._updatestatus(status.READY)

        # Aspetto un altro po' per evitare di chiedere di fare le misure contemporaneamente agli altri
        sleep(random_sleep)
      elif made >= 1:
        wait_next = max(self._polling * 3, 180)
        # Ritardo la richiesta per le successive: dovrebbe essere maggiore del tempo per effettuare una misura, altrimenti eseguo MAX_MEASURES_PER_HOUR + 1
        logger.info('Ho fatto almento una misura. Aspetto %d secondi per il prossimo polling.' % wait_next)
        sleep(wait_next)
      else:
        # Aspetto prima di richiedere il task
        sleep(self._polling)
    else:
      # Aspetto prima di richiedere il task
      sleep(self._polling)
Example #16
0
    def testping(self):
        # si utilizza funzione ping.py
        test_type = 'ping'
        start = datetime.fromtimestamp(timestampNtp())
        elapsed = 0

        try:
            # Il risultato deve essere espresso in millisecondi
            elapsed = ping.do_one(self._host.ip, self._timeout) * 1000

        except Exception as e:
            errorcode = errors.geterrorcode(e)
            error = '[%s] Errore durante la misura %s: %s' % (errorcode,
                                                              test_type, e)
            logger.error(error)
            raise Exception(error)

        if (elapsed == None):
            elapsed = 0

        return Proof(test_type, start=start, value=elapsed, bytes=0)
Example #17
0
    def testftpup(self, bytes, path):
        global ftp, file, size, filepath
        filepath = path
        test_type = 'upload'
        size = 0
        elapsed = 0

        file = Fakefile(bytes)
        timeout = max(self._timeout, 12)
        start = datetime.fromtimestamp(timestampNtp())

        try:
            ftp = FTP(self._host.ip,
                      self._username,
                      self._password,
                      timeout=timeout)
        except ftplib.all_errors as e:
            errorcode = errors.geterrorcode(e)
            error = '[%s] Impossibile aprire la connessione FTP: %s' % (
                errorcode, e)
            logger.error(error)
            raise Exception(error)

        # TODO Se la connessione FTP viene invocata con timeout, il socket è non-blocking e il sistema può terminare i buffer di rete: http://bugs.python.org/issue8493
        function = '''ftp.storbinary('STOR %s' % filepath, file, callback=totalsize)'''
        setup = 'from %s import file, ftp, totalsize, filepath' % __name__
        timer = timeit.Timer(function, setup)

        try:
            logger.debug('Test initializing...')
            start_total_bytes = self._netstat.get_tx_bytes()

            logger.debug('Testing... ')
            #       pcapper.sniff(Contabyte(self._if_ip, self._host.ip))

            # Il risultato deve essere espresso in millisecondi
            elapsed = timer.timeit(1) * 1000

            #       pcapper.stop_sniff()
            #       counter_stats = pcapper.get_stats()

            logger.debug('Test stopping... ')
            end_total_bytes = self._netstat.get_tx_bytes()
            logger.debug('Test done!')

        except ftplib.all_errors as e:
            errorcode = errors.geterrorcode(e)
            error = '[%s] Impossibile effettuare il test %s: %s' % (
                errorcode, test_type, e)
            logger.error(error)
            raise Exception(error)

        except Exception as e:
            errorcode = errors.geterrorcode(e)
            error = '[%s] Errore durante la misura %s: %s' % (errorcode,
                                                              test_type, e)
            logger.error(error)
            raise Exception(error)

        ftp.quit()
        ''' TODO: get packet drop from netstat '''
        counter_stats = Statistics(byte_up_nem=size,
                                   byte_up_all=end_total_bytes -
                                   start_total_bytes,
                                   packet_drop=0,
                                   packet_tot_all=100)
        #     return Proof(test_type, start, elapsed, size, counter_stats)
        return Proof(test_type, start, elapsed, size, counter_stats)
Example #18
0
    def testftpdown(self, filename):
        global ftp, file, size
        test_type = 'download'
        size = 0
        elapsed = 0

        file = filename
        timeout = max(self._timeout, 12)
        start = datetime.fromtimestamp(timestampNtp())

        try:
            ftp = FTP(self._host.ip,
                      self._username,
                      self._password,
                      timeout=timeout)
        except ftplib.all_errors as e:
            errorcode = errors.geterrorcode(e)
            error = '[%s] Impossibile aprire la connessione FTP: %s' % (
                errorcode, e)
            logger.error(error)
            raise Exception(error)

        function = '''ftp.retrbinary('RETR %s' % file, totalsize)'''
        setup = 'from %s import ftp, file, totalsize' % __name__
        timer = timeit.Timer(function, setup)

        try:
            logger.debug('Test initializing...')
            start_total_bytes = self._netstat.get_rx_bytes()
            logger.debug('Testing... ')

            # Il risultato deve essere espresso in millisecondi
            elapsed = timer.timeit(1) * 1000

            logger.debug('Test stopping... ')
            end_total_bytes = self._netstat.get_rx_bytes()

            logger.debug('Test done!')

        except ftplib.all_errors as e:
            errorcode = errors.geterrorcode(e)
            error = '[%s] Impossibile effettuare il test %s: %s' % (
                errorcode, test_type, e)
            logger.error(error)
            raise Exception(error)

        except Exception as e:
            errorcode = errors.geterrorcode(e)
            error = '[%s] Errore durante la misura %s: %s' % (errorcode,
                                                              test_type, e)
            logger.error(error)
            raise Exception(error)

        ftp.quit()
        ''' TODO: get packet drop from netstat '''
        counter_stats = Statistics(byte_down_nem=size,
                                   byte_down_all=end_total_bytes -
                                   start_total_bytes,
                                   packet_drop=0,
                                   packet_tot_all=100)
        return Proof(test_type, start, elapsed, size, counter_stats)
Example #19
0
  def loop(self):

    # signal.signal(signal.SIGALRM, runtimewarning)
    t = None

    # Open socket for GUI dialog
    self._communicator = _Communicator()
    self._communicator.start()

    # Prepare Progress file
    progressurl = self._progressurl
    clientid = self._client.id
    self._progress = Progress(clientid = clientid, progressurl = progressurl)

    # Controllo se 
    # - non sono trascorsi 3 giorni dall'inizio delle misure
    # - non ho finito le misure
    # - sono una sonda
    while self._isprobe or (not self._progress.doneall() and self._progress.onair()):

      bandwidth_sem.acquire() # Richiedi accesso esclusivo alla banda

      if not self._hourisdone():

        self._updatestatus(status.READY)
        task = None

        # Solo se sono una sonda invio i file di misura nella cartella da spedire
        if self._isprobe:
          # Controllo se ho dei file da mandare prima di prendermi il compito di fare altre misure
          self._uploadall()

        try:
          task = self._download()
        except Exception as e:
          logger.error('Errore durante la ricezione del task per le misure: %s' % e)
          self._updatestatus(Status(status.ERROR, 'Errore durante la ricezione del task per le misure: %s' % e))

        # Se ho scaricato un task imposto l'allarme
        if (task != None):
          logger.debug('Trovato task %s' % task)

          if (task.message != None and len(task.message) > 0):
            logger.debug("Trovato messaggio: %s" % task.message)
            self._updatestatus(Status(status.MESSAGE, task.message))

          if (task.now):
            # Task immediato
            alarm = 5.00
          else:
            delta = task.start - datetime.fromtimestamp(timestampNtp())
            alarm = delta.days * 86400 + delta.seconds

          if alarm > 0 and (task.download > 0 or task.upload > 0 or task.ping > 0):
            logger.debug('Impostazione di un nuovo task tra: %s secondi' % alarm)
            self._updatestatus(Status(status.READY, 'Inizio misura tra pochi secondi...'))
            # Imposta l'allarme che eseguirà i test quando richiesto dal task

            # Prima cancella il vecchio allarme
            try:
              if (t != None):
                t.cancel()
            except NameError:
              pass
            except AttributeError:
              pass

            # Imposta il nuovo allarme
            t = Timer(alarm, self._dotask, [task])
            t.start()
      else:
        self._updatestatus(status.PAUSE)

      bandwidth_sem.release() # Rilascia l'accesso esclusivo alla banda

      # Attendi il prossimo polling
      self.wait()

    while True:
      self._updatestatus(status.FINISHED)
      sleep(float(self._polling * 3))
Example #20
0
  def _dotask(self, task):
    '''
    Esegue il complesso di test prescritti dal task entro il tempo messo a
    disposizione secondo il parametro tasktimeout
    '''
    # TODO Mischiare i test: down, up, ping, down, up, ping, ecc...

    if not self._isprobe and self._progress != None:
      made = self._progress.howmany(datetime.fromtimestamp(timestampNtp()).hour)
      if made >= MAX_MEASURES_PER_HOUR:
        self._updatestatus(status.PAUSE)
        return

    bandwidth_sem.acquire()  # Acquisisci la risorsa condivisa: la banda

    logger.info('Inizio task di misura verso il server %s' % task.server)

    # Area riservata per l'esecuzione della misura
    # --------------------------------------------------------------------------

    # TODO Inserire il timeout complessivo di task (da posticipare)
    try:

      self._updatestatus(status.PLAY)

      # Profilazione iniziale del sistema
      # ------------------------
      base_error = 0
      if self._profile_system() != 0:
        base_error = 50000

#       ip = sysmonitor.getIp(task.server.ip, 21)
      dev = sysmonitor.getDev(task.server.ip, 21)
      t = Tester(dev = dev, host = task.server, timeout = self._testtimeout,
                 username = self._client.username, password = self._client.password)

      # TODO Pensare ad un'altra soluzione per la generazione del progressivo di misura
      start = datetime.fromtimestamp(timestampNtp())
      id = start.strftime('%y%m%d%H%M')
      m = Measure(id, task.server, self._client, __version__, start.isoformat())

      # Set task timeout alarm
      # signal.alarm(self._tasktimeout)

      # Testa gli ftp down
      # ------------------------
      i = 1;
      while (i <= task.download):
        self._updatestatus(status.Status(status.PLAY, "Esecuzione Test %d su %d" % (i, task.download + task.upload + task.ping)))
        try:
          # Profilazione del sistema
          error = self._profile_system(sysmonitor.CHECK_ALL);

          # Esecuzione del test
          logger.info('Starting ftp download test (%s) [%d]' % (task.ftpdownpath, i))
          test = t.testftpdown(task.ftpdownpath)

          # Gestione degli errori nel test
          if error > 0 or base_error > 0:
            test.seterrorcode(error + base_error)

          # Analisi da contabit
          self._test_gating(test, DOWN)

          # Salvataggio della misura
          logger.debug('Download result: %.3f' % test.value)
          logger.debug('Download error: %d, %d, %d' % (base_error, error, test.errorcode))
          m.savetest(test)
          i = i + 1

          # Prequalifica della linea
          if (test.value > 0):
            bandwidth = int(round(test.bytes * 8 / test.value))
            logger.debug('Banda ipotizzata in download: %d' % bandwidth)
            task.update_ftpdownpath(bandwidth)

          sleep(1)

        # Cattura delle eccezioni durante la misura
        except Exception as e:
          if not datetime.fromtimestamp(timestampNtp()).hour == start.hour:
            raise e
          else:
            logger.warning('Misura sospesa per eccezione %s' % e)
            self._updatestatus(status.Status(status.ERROR, 'Misura sospesa per errore: %s Aspetto %d secondi prima di proseguire la misura.' % (e, TIME_LAG)))
            sleep(TIME_LAG)
            logger.info('Misura in ripresa dopo sospensione. Test download %d di %d' % (i, task.download))
            self._updatestatus(status.Status(status.PLAY, 'Proseguo la misura. Misura in esecuzione'))

      # Testa gli ftp up
      i = 1;
      while (i <= task.upload):
        self._updatestatus(status.Status(status.PLAY, "Esecuzione Test %d su %d" % (i + task.download, task.download + task.upload + task.ping)))
        try:
          # Profilazione del sistema
          error = self._profile_system(sysmonitor.CHECK_ALL);

          # Esecuzione del test
          logger.debug('Starting ftp upload test (%s) [%d]' % (task.ftpuppath, i))
          test = t.testftpup(self._client.profile.upload * task.multiplier * 1000 / 8, task.ftpuppath)

          # Gestione degli errori nel test
          if error > 0 or base_error > 0:
            test.seterrorcode(error + base_error)

          # Analisi da contabit
          self._test_gating(test, UP)

          # Salvataggio del test nella misura
          logger.debug('Upload result: %.3f' % test.value)
          logger.debug('Upload error: %d, %d, %d' % (base_error, error, test.errorcode))
          m.savetest(test)
          i = i + 1

          # Prequalifica della linea
          if (test.value > 0):
            bandwidth = int(round(test.bytes * 8 / test.value))
            logger.debug('Banda ipotizzata in upload: %d' % bandwidth)
            self._client.profile.upload = bandwidth

          sleep(1)

        # Cattura delle eccezioni durante la misura
        except Exception as e:
          if not datetime.fromtimestamp(timestampNtp()).hour == start.hour:
            raise e
          else:
            logger.warning('Misura sospesa per eccezione %s' % e)
            self._updatestatus(status.Status(status.ERROR, 'Misura sospesa per errore: %s Aspetto %d secondi prima di proseguire la misura.' % (e, TIME_LAG)))
            sleep(TIME_LAG)
            logger.info('Misura in ripresa dopo sospensione. Test upload %d di %d' % (i, task.upload))
            self._updatestatus(status.Status(status.PLAY, 'Proseguo la misura. Misura in esecuzione'))

      # Testa i ping
      i = 1
      while (i <= task.ping):
        self._updatestatus(status.Status(status.PLAY, "Esecuzione Test %d su %d" % (i + task.download + task.upload, task.download + task.upload + task.ping)))
        try:
          # Profilazione del sistema
          error = self._profile_system(sysmonitor.CHECK_MEDIUM);

          # Esecuzione del test
          logger.debug('Starting ping test [%d]' % i)
          test = t.testping()

          # Gestione degli errori nel test
          if error > 0 or base_error > 0:
            test.seterrorcode(error + base_error)

          # Salvataggio del test nella misura
          logger.debug('Ping result: %.3f' % test.value)
          logger.debug('Ping error: %d, %d, %d' % (base_error, error, test.errorcode))
          m.savetest(test)
          i = i + 1

          if ((i - 1) % task.nicmp == 0):
            sleep(task.delay)

        # Cattura delle eccezioni durante la misura
        except Exception as e:
          if not datetime.fromtimestamp(timestampNtp()).hour == start.hour:
            raise e
          else:
            logger.warning('Misura sospesa per eccezione %s' % e)
            self._updatestatus(status.Status(status.ERROR, 'Misura sospesa per errore: %s Aspetto 10 secondi prima di proseguire la misura.' % e))
            sleep(10)
            logger.info('Misura in ripresa dopo sospensione. Test ping %d di %d' % (i, task.ping))
            self._updatestatus(status.Status(status.PLAY, 'Proseguo la misura. Misura in esecuzione'))

      # Unset task timeout alarm
      # signal.alarm(0)

      # Spedisci il file al repository delle misure
      sec = datetime.fromtimestamp(timestampNtp()).strftime('%S')
      f = open('%s/measure_%s%s.xml' % (self._outbox, m.id, sec), 'w')
      f.write(str(m))

      # Aggiungi la data di fine in fondo al file
      f.write('\n<!-- [finished] %s -->' % datetime.fromtimestamp(timestampNtp()).isoformat())
      f.close()

      if (not self._local):
        upload = self._upload(f.name)
        if upload:
          self._updatestatus(status.Status(status.OK, 'Misura terminata con successo.'))
        else:
          self._updatestatus(status.Status(status.ERROR, 'Misura terminata ma un errore si è verificato durante il suo invio.'))
      else:
        self._updatestatus(status.Status(status.OK, 'Misura terminata.'))

      logger.info('Fine task di misura.')

    except RuntimeWarning:
      self._updatestatus(status.Status(status.ERROR, 'Misura interrotta per timeout.'))
      logger.warning('Timeout during task execution. Time elapsed > %1f seconds ' % self._tasktimeout)

    except Exception as e:
      logger.error('Task interrotto per eccezione durante l\'esecuzione di un test: %s' % e)
      self._updatestatus(status.Status(status.ERROR, 'Misura interrotta. %s Attendo %d secondi' % (e, self._polling)))

    bandwidth_sem.release() # Rilascia la risorsa condivisa: la banda
Example #21
0
def getdate():
  return datetime.fromtimestamp(timestampNtp())
Example #22
0
def getdate():
    return datetime.fromtimestamp(timestampNtp())