Script Python per monitorare la connessione di rete

La necessità di avere i nostri dispositivi sempre connessi a Internet sta diventando più un bisogno di base che un ulteriore privilegio.

Avere applicazioni e dispositivi che devono registrare, inviare e ricevere dati nel mondo esterno è fondamentale. Pertanto, avere uno strumento che ti consente di monitorare quando la rete scende può aiutarti a risolvere la rete o interrompere le applicazioni prima di inviare un mucchio di errori di registro.

Nel tutorial di oggi, creeremo un semplice monitor di rete che monitora continuamente la tua connettività Internet inviando richieste di ping a una risorsa esterna. Lo script che creeremo deve anche mantenere i registri di quando Internet è inattivo e la durata dei tempi di inattività:

Requisiti del progetto

Per questo progetto, avremo solo bisogno di:

• Python Programming Basics
• Comprensione di base delle reti di computer.
• Sentirsi a tuo agio nell'uso del terminale.

Logica del progetto

Prima di immergerci nella parte di codifica, discutiamo e comprendiamo cosa stiamo cercando di ottenere:

Cos'è la rete su e tempo di inattività?

Quando parliamo di tempo di rete e di inattività, 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ù tempo di inattività.

Come determinare i tempi di inattività

Ora che sappiamo cos'è i tempi di inattività di Internet, potresti chiederti: "Come possiamo determinarlo?"

Senza complicare il nostro codice, possiamo andare con il ping. Un ping è un metodo in cui ping continuamente un server affidabile, forse cloudflare o Google DNS, e quindi aspettiamo una risposta.

Se eseguiamo il ping del server e non c'è risposta, notiamo che tempo specifico e continuiamo a eseguire il ping fino a quando non riceviamo un ping e notiamo il tempo.

Avendo la differenza di tempo, possiamo notare quando Internet è sceso e per quanto tempo.

Dobbiamo anche stare attenti quando pingiamo un singolo server perché possiamo avere il ping erroneamente come un attacco DDoS, il che potrebbe far sì che il nostro indirizzo IP venga bloccato, il che produrrebbe risultati negativi.

Ecco un diagramma di flusso che spiega questo concetto:

Parlare è economico; Ora immergiamoti nel codice che mostra come implementare questa logica:

Ora mostrami il codice

Come al solito, a Python, iniziamo importando le biblioteche richieste. Successivamente, creiamo un file di registro nella directory di lavoro corrente.

Utilizziamo 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 up -upt molto elevato. Passiamo anche la porta e, poiché è un server DNS, usiamo la porta 53.

Verifichiamo quindi di avere accesso alla directory dei file di registro e smettere 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.

Società di importazione
tempo di importazione
Importa DateTime
Import OS
Import sys
Log_fname = "rete.tronco d'albero"
File = os.sentiero.Unisciti (OS.getCwd (), log_fname)
def send_ping_request (host = "1.1.1.1 ", porta = 53, timeout = 3):
Tentativo:
PRESA.setDefaultTimeout (timeout)
S = socket.Socket (presa.Af_inet, socket.Sock_Stream)
S.connect ((host, porta))
Tranne Oserror come errore:
restituire false
altro:
S.vicino()
restituire vero
def write_permission_check ():
Tentativo:
con aperto (file, "a") come file:
passaggio
Tranne Oserror come errore:
Stampa ("Regdi Creazione del file non riuscita")
sys.Uscita()
Finalmente:
passaggio
def calcocula_time (avvia, stop):
time_difference = stop - avvia
Seconds = Float (STR (time_difference.total_seconds ()))
return STR (DateTime.timedelta (secondi = secondi)).diviso(".") [0]
def mon_net_connection (ping_freq = 2):
Monitor_start_time = datetime.appuntamento.Ora()
MOTD = "Monitoraggio della connessione di rete avviato a:" + STR (monitor_start_time).diviso(".") [0] +" Invio di richiesta ping in " + str (ping_freq) +" secondi "
Stampa (MOTD)
con aperto (file, "a") come file:
file.Scrivi ("\ n")
file.Scrivi (motd + "\ n")
mentre è vero:
Se send_ping_request ():
tempo.sleep (ping_freq)
altro:
down_time = datetime.appuntamento.Ora()
fail_msg = "connessione di rete non disponibile a:" + str (down_time).diviso(".") [0]
Print (fail_msg)
con aperto (file, "a") come file:
file.Scrivi (fail_msg + "\ n")
i = 0
mentre non send_ping_request ():
tempo.sonno (1)
i += 1
Se i> = 3600:
i = 0
ora = datetime.appuntamento.Ora()
Continus_Message = "Network Unvailability persistente a:" + STR (ora).diviso(".") [0]
Print (ContinOus_Message)
con aperto (file, "a") come file:
file.Scrivi (Continus_Message + "\ n")
up_time = datetime.appuntamento.Ora()
uptime_message = "connettività di rete ripristinata a:" + str (up_time).diviso(".") [0]
down_time = calculate_time (down_time, up_time)
_m = "La connessione di rete non era disponibile per" + down_time
Stampa (uptime_message)
Stampa (_M)
con aperto (file, "a") come file:
file.Scrivi (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 fino a quando non è disponibile. Questo semplice script è aperto a miglioramenti. Sentiti libero di regolare il codice per soddisfare le tue esigenze ed espanderlo su di esso.