def upload_successful(self, d, f, upload_time):
"""
Un device "d" carica in upload correttamente il file "f"
:param d: device
:param f: file caricato
:param upload_time: tempo di upload
"""
self.upload_for_success.append(
ts.TimedData(d.id + f.get_id(), upload_time, timestamp=False)
)
def download_start(self, d, f):
"""
Un device "d" inizia a scaricare il file "f" dal server
"""
# Timestamp corrente
t = self.now()
# Ho un nuovo file in download
self.current_downloading += 1
# Aggiorno il numero di download in parallelo nello storico dati
self.downloading.insert_or_update(t, self.current_downloading)
# Salvo l'informazione di download, per calcolare al suo termine la durata del trasferimento
self.pending_download.append(ts.TimedData(str(d.id) + '_' + str(f.get_id()), t))
def login(self, d):
"""
Un nuovo device "d" effettua il login
"""
# Timestamp corrente
t = self.now()
# Ho un nuovo device connesso
self.current_online_devices += 1
# Aggiorno il numero di dispositivi connessi nello storico dati
self.online_devices.insert_or_update(t, self.current_online_devices)
# Salvo l'informazione di login, per calcolare al momento del logout la durata della sessione
self.pending_online.append(ts.TimedData(d.id, t))
def logout(self, d):
"""
Un device "d" effettua il logout
"""
# Timestamp corrente
t = self.now()
# Ho un device che si disconnette
self.current_online_devices -= 1
# Aggiorno il numero di dispositivi connessi nello storico daticurrent_uploading
self.online_devices.insert_or_update(t, self.current_online_devices)
# Ricavo la durata di sessione, partendo dal timestamp di login
x = self.pending_online.search_by_data(d.id)[0]
self.pending_online.remove(x)
t_login = x.get_time()
session = t - t_login
self.online_for.append(
ts.TimedData(d.id, session, timestamp=False)
)
def upload_end(self, d, f, up_rate):
"""
Un device "d" finisce di caricare il file "f"
"""
# Timestamp corrente
t = self.now()
# Ho un upload che termina (con o senza successo)
self.current_uploading -= 1
# Aggiorno il numero di download in parallelo nello storico dati
self.uploading.insert_or_update(t, self.current_uploading)
# Ricavo la durata del trasferimento, partendo dal timestamp di inizio upload
x = self.pending_upload.search_by_data(d.id + f.get_id())[0]
self.pending_upload.remove(x)
t_login = x.get_time()
session = t - t_login
self.upload_for.append(
ts.TimedData(d.id + f.get_id(), session, timestamp=False)
)
# Valori di carico sul server
i = t_login
while i <= t:
self.server_load_in[i - 1] += up_rate
i += 1
def download_end(self, d, f, dw_rate):
"""
Un device "d" finisce di scaricare il file "f"
"""
# Timestamp corrente
t = self.now()
# Ho un download che termina (con o senza successo)
self.current_downloading -= 1
# Aggiorno il numero di download in parallelo nello storico dati
self.downloading.insert_or_update(t, self.current_downloading)
# Ricavo la durata del trasferimento, partendo dal timestamp di inizio download
x = self.pending_download.search_by_data(str(d.id) + '_' + str(f.get_id()))[0]
self.pending_download.remove(x)
t_start = x.get_time()
dw_duration = t - t_start
self.download_for.append(
ts.TimedData(d.id + f.get_id(), dw_duration, timestamp=False)
)
# Valori di carico sul server
i = t_start
while i <= t:
self.server_load_out[i - 1] += dw_rate
i += 1
self.server_downloaded_data += dw_duration * dw_rate