Python -skript for å overvåke nettverkstilkobling

Behovet for å ha enhetene våre alltid koblet til internett blir mer et grunnleggende behov enn et ekstra privilegium.

Å ha applikasjoner og enheter som trenger å logge, sende og motta data til omverdenen er kritisk. Å ha et verktøy som lar deg overvåke når nettverket ditt går ned kan hjelpe deg med å feilsøke nettverket eller stoppe applikasjonene før du sender en haug med loggfeil.

I dagens opplæring vil vi bygge en enkel nettverksmonitor som kontinuerlig overvåker internettforbindelsen din ved å sende pingforespørsler til en ekstern ressurs. Skriptet vi skal opprette, skal også holde logger over når internett er nede og varigheten av driftsstansen:

Prosjektkrav

For dette prosjektet vil vi bare trenge:

• Basics Python Programmering
• Grunnleggende forståelse av datanettverk.
• Vær komfortabel med å bruke terminalen.

Prosjektlogikk

Før vi dykker inn i kodingsdelen, la oss diskutere og forstå hva vi prøver å oppnå:

Hva er nettverk opp og driftsstans?

Når vi snakker om nettverk opp og driftsstans, mener vi perioden der nettverkstilkoblingen er helt utilgjengelig, og dermed kan vi ikke kommunisere med enheter utenfor nettverket vårt. Jo lenger internett er utilgjengelig, jo lengre driftsstans.

Hvordan bestemme driftsstans

Nå som vi vet hva driftsstans på internett er, lurer du kanskje på: "Hvordan går vi for å bestemme det?”

Uten å komplisere koden vår, kan vi gå med ping. En ping er en metode der vi kontinuerlig ping en pålitelig server-kanskje Cloudflare eller Google DNS-og deretter vent på svar.

Hvis vi ping serveren og det ikke er noe svar, bemerker vi at spesifikk tid og fortsetter å pinge til vi mottar en ping og noterer tiden.

Å ha tidsforskjellen, kan vi merke oss når internett var nede og hvor lenge.

Vi må også være forsiktige når vi pinger en enkelt server fordi vi kan få pingen feilaktig feil som et DDoS -angrep, noe som kan føre til at vår IP -adresse blir blokkert, noe som vil gi negative resultater.

Her er et flytskjema som forklarer dette konseptet:

Snakk er billig; La oss nå dykke inn i koden som viser hvordan du implementerer denne logikken:

Vis meg nå koden

Som vanlig begynner vi i Python med å importere de nødvendige bibliotekene. Deretter oppretter vi en loggfil i den gjeldende arbeidskatalogen.

Vi bruker socketbiblioteket til å sende en forespørsel til en ekstern IP -adresse i den første funksjonen. For dette eksemplet bruker vi CloudFlare Public DNS -adresse, som har en veldig høy oppetid. Vi passerer også porten, og siden det er en DNS -server, bruker du port 53.

Vi bekrefter da at vi har tilgang til loggfilkatalogen og slutter hvis vi ikke har tilgang.

Neste trinn er å beregne tiden nettverkstilkoblingen er nede. Til slutt pakker vi hele funksjonaliteten i en sløyfe, som vist i koden nedenfor.

Importkontakt
Importer tid
Importer DateTime
Importer OS
Importer Sys
Log_fname = "nettverk.Logg"
Fil = OS.sti.Bli med (OS.getcwd (), log_fname)
def send_ping_request (host = "1.1.1.1 ", port = 53, timeout = 3):
prøve:
stikkontakt.setDefaultTimeout (timeout)
S = stikkontakt.stikkontakt (stikkontakt.Af_inet, stikkontakt.SOCK_STREAM)
s.Connect ((vert, port))
Bortsett fra Oserror som feil:
return falsk
ellers:
s.Lukk()
Returner sann
def writ_permission_check ():
prøve:
med åpen (fil, "a") som fil:
sende
Bortsett fra Oserror som feil:
Print ("Loggfiloppretting mislyktes")
sys.exit()
endelig:
sende
def calculat_time (start, stopp):
TIME_DIFFERENS = STOP - Start
Seconds = Float (STR (TIME_DIFFERENS.Total_seconds ()))
Return Str (DateTime.Timedelta (sekunder = sekunder)).dele(".") [0]
def mon_net_connection (ping_freq = 2):
Monitor_Start_Time = DateTime.dato tid.nå()
MOTD = "Monitoring av nettverkstilkobling startet på:" + str (Monitor_start_time).dele(".") [0] +" Send ping -forespørsel i " + str (ping_freq) +" Seconds "
Print (MOTD)
med åpen (fil, "a") som fil:
fil.Skriv ("\ n")
fil.Skriv (MOTD + "\ n")
Mens sant:
Hvis send_ping_request ():
tid.søvn (ping_freq)
ellers:
Down_Time = DateTime.dato tid.nå()
FAIL_MSG = "Nettverkstilkobling utilgjengelig på:" + str (down_time).dele(".") [0]
print (fail_msg)
med åpen (fil, "a") som fil:
fil.skriv (fail_msg + "\ n")
i = 0
Mens du ikke send_ping_request ():
tid.søvn (1)
i += 1
Hvis jeg> = 3600:
i = 0
Nå = DateTime.dato tid.nå()
Continuous_Message = "Nettverk Unavailabilty vedvarende på:" + Str (nå).dele(".") [0]
Print (Continuous_Message)
med åpen (fil, "a") som fil:
fil.Skriv (Continuous_Message + "\ n")
up_time = DateTime.dato tid.nå()
UPTime_Message = "Nettverkstilkobling gjenopprettet på:" + str (up_time).dele(".") [0]
down_time = calculat_time (down_time, up_time)
_M = "Nettverkstilkobling var utilgjengelig for" + down_time
Print (UPTime_Message)
Print (_M)
med åpen (fil, "a") som fil:
fil.Skriv (UPTime_Message + "\ n")
fil.Skriv (_M + "\ n")
mon_net_connection ()

Hvis du kjører dette skriptet, vil du få en utdata som ligner den som er vist nedenfor:

Konklusjon

Ved hjelp av skriptet ovenfor kan vi overvåke når nettverkstilkoblingen går tapt og hele tiden logge det til den er tilgjengelig. Dette enkle skriptet er åpent for forbedringer. Juster gjerne koden for å passe dine behov og utvide den.