Phenquestions
Avere applicazioni e dispositivi che devono registrare, inviare e ricevere dati verso il mondo esterno è fondamentale. Pertanto, avere uno strumento che ti permetta di monitorare quando la tua rete si interrompe può aiutarti a risolvere i problemi della rete o arrestare le applicazioni prima di inviare una serie di errori di registro.
Nel tutorial di oggi, costruiremo un semplice monitor di rete che monitora continuamente la tua connettività Internet inviando richieste di ping a una risorsa esterna. Lo script che creeremo conserverà anche i registri di quando Internet non è attivo e la durata del tempo di inattività:
Requisiti del progetto
Per questo progetto, avremo solo bisogno di:
- Nozioni di base sulla programmazione Python Python
- Conoscenza di base delle reti di computer.
- Stai comodo usando il terminale.
Logica del progetto
Prima di immergerci nella parte di codifica, discutiamo e capiamo cosa stiamo cercando di ottenere:
Che cos'è la rete attiva e i tempi di inattività??
Quando parliamo di up e downtime della rete, intendiamo il periodo in cui la connessione di rete è del tutto non disponibile e, quindi, non possiamo comunicare con dispositivi al di fuori della nostra rete. Più a lungo Internet non è disponibile, più lunghi sono i tempi di inattività.
Come determinare i tempi di inattività
Ora che sappiamo cos'è il tempo di inattività di Internet, ti starai chiedendo: "come possiamo determinarlo??"
Senza complicare il nostro codice, possiamo andare con ping. Un ping è un metodo in cui eseguiamo continuamente il ping di un server affidabile, ad esempio Cloudflare o Google DNS, e quindi aspettiamo una risposta.
Se eseguiamo il ping del server e non c'è risposta, prendiamo nota dell'ora specifica e continuiamo a eseguire il ping finché non riceviamo un ping e annotiamo l'ora.
Avendo la differenza di fuso orario, possiamo notare quando Internet è stato disattivato e per quanto tempo.
Dobbiamo anche fare attenzione quando eseguiamo il ping di un singolo server perché possiamo scambiare il ping come un attacco DDoS, il che potrebbe causare il blocco del nostro indirizzo IP, il che produrrebbe risultati negativi.
Ecco un diagramma di flusso che spiega questo concetto:
Parlare è economico; entriamo ora nel codice che mostra come implementare questa logica:
Ora mostrami il codice
Come al solito, in Python, iniziamo importando le librerie richieste. Successivamente, creiamo un file di registro nella directory di lavoro corrente.
Usiamo la libreria socket per inviare una richiesta a un indirizzo IP esterno nella prima funzione. Per questo esempio, utilizziamo l'indirizzo DNS pubblico di Cloudflare, che ha un tempo di attività molto elevato. Passiamo anche la porta, e poiché è un server DNS, usa la porta 53.
Quindi verifichiamo di avere accesso alla directory del file di registro e chiudiamo se non abbiamo accesso.
Il prossimo passo è calcolare il tempo in cui la connessione di rete è inattiva. Infine, avvolgiamo l'intera funzionalità in un ciclo, come mostrato nel codice seguente.
presa di importazionetempo di importazione
data e ora di importazione
importare il sistema operativo
sistema di importazione
LOG_FNAME = "rete.registro"
FILE = os.sentiero.unisciti (os.getcwd(), LOG_FNAME)
def send_ping_request(host="1.1.1.1", porta=53, timeout=3):
provare:
presa.setdefaulttimeout(timeout)
s = presa.presa (presa).AF_INET, presa.SOCK_STREAM)
S.connect((host,porta))
tranne OSError come errore:
ritorno Falso
altro:
S.vicino()
ritorna Vero
def write_permission_check():
provare:
con open(FILE, "a") come file:
passaggio
tranne OSError come errore:
print("Creazione del file di registro fallita")
sistema.Uscita()
finalmente:
passaggio
def calcola_tempo(inizio, fine):
time_difference = stop - start
secondi = float(str(time_difference.secondi_totali()))
return str(datetime.timedelta(secondi=secondi)).Diviso(".")[0]
def mon_net_connection(ping_freq=2):
monitor_start_time = datetime.appuntamento.adesso()
motd = "Monitoraggio della connessione di rete avviato alle: " + str(monitor_start_time).Diviso(".")[0] + " Invio richiesta ping in " + str(ping_freq) + " secondi"
stampa (motivo)
con open(FILE, "a") come file:
file.scrivi("\n")
file.write(motd + "\n")
mentre vero:
if send_ping_request():
tempo.sleep(ping_freq)
altro:
down_time = datetime.appuntamento.adesso()
fail_msg = "Connessione di rete non disponibile a: " + str(down_time).Diviso(".")[0]
print(fail_msg)
con open(FILE, "a") come file:
file.write(fail_msg + "\n")
io = 0
pur non send_ping_request():
tempo.dormire(1)
io += 1
se io >= 3600:
io = 0
ora = data e ora.appuntamento.adesso()
continueus_message = "Indisponibilità rete persistente su: " + str (ora).Diviso(".")[0]
print(continous_message)
con open(FILE, "a") come file:
file.write(messaggio_continuo + "\n")
up_time = datetime.appuntamento.adesso()
uptime_message = "Connettività di rete ripristinata alle: " + str(up_time).Diviso(".")[0]
down_time = calcola_tempo(down_time, up_time)
_m = "La connessione di rete non era disponibile per " + down_time
print(uptime_message)
stampa(_m)
con open(FILE, "a") come file:
file.write(uptime_message + "\n")
file.scrivi(_m + "\n")
mon_net_connection()
Se esegui questo script, otterrai un output simile a quello mostrato di seguito:
Conclusione
Utilizzando lo script sopra, possiamo monitorare quando la connessione di rete viene persa e registrarla costantemente finché non è disponibile. Questo semplice script è aperto a miglioramenti. Sentiti libero di modificare il codice in base alle tue esigenze e ampliarlo.
