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
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
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)
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
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
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)
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
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
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()
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
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
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()
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
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)
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)
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)
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)
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)
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))
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
def getdate(): return datetime.fromtimestamp(timestampNtp())
def getdate():
return datetime.fromtimestamp(timestampNtp())