Phenquestions
Å ha applikasjoner og enheter som trenger å logge, sende og motta data til omverdenen er avgjørende. Å ha et verktøy som lar deg overvåke når nettverket ditt går ned, kan dermed 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 ping-forespørsler til en ekstern ressurs. Skriptet vi skal lage skal også føre logger over når Internett er nede og varigheten av nedetid:
Prosjektkrav
For dette prosjektet trenger vi bare:
- Grunnleggende om Python-programmering
- Grunnleggende forståelse av datanettverk.
- Vær komfortabel med terminalen.
Prosjektlogikk
Før vi dykker inn i kodingsdelen, la oss diskutere og forstå hva vi prøver å oppnå:
Hva er Network Up and Downtime?
Når vi snakker om nettverk opp og nedetid, 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 lenger nedetid.
Hvordan bestemme nedetid
Nå som vi vet hva nedetid på internett er, kan du lure på, “hvordan skal vi bestemme det?”
Uten å komplisere koden vår, kan vi gå med ping. En ping er en metode der vi kontinuerlig pinger en pålitelig server - kanskje Cloudflare eller Google DNS - og deretter venter på svar.
Hvis vi pinger på serveren og det ikke er noe svar, noterer vi oss den spesifikke tiden og fortsetter å pinge til vi mottar et ping og noterer tiden.
Når vi har tidsforskjellen, kan vi merke 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 feilaktig som et DDoS-angrep, noe som kan føre til at IP-adressen vår blir blokkert, noe som vil gi negative resultater.
Her er et flytskjema som forklarer dette konseptet:
Snakk er billig; la oss nå dykke ned i koden som viser hvordan du implementerer denne logikken:
Vis meg koden
Som vanlig, i Python, starter vi med å importere de nødvendige bibliotekene. Deretter oppretter vi en loggfil i gjeldende arbeidskatalog.
Vi bruker socketbiblioteket til å sende en forespørsel til en ekstern IP-adresse i den første funksjonen. For dette eksemplet bruker vi Cloudflare offentlige DNS-adresse, som har veldig høy oppetid. Vi passerer også porten, og siden det er en DNS-server, bruk 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 løkke, som vist i koden nedenfor.
importkontaktimporttid
importer datatid
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.koble til ((vert, port))
unntatt OSError som feil:
returner Falsk
ellers:
s.Lukk()
returner True
def write_permission_check ():
prøve:
med åpen (FIL, "a") som fil:
sende
unntatt OSError som feil:
skriv ut ("Opprettelse av loggfil mislyktes")
sys.exit()
endelig:
sende
def beregne tid (start, stopp):
time_difference = stopp - start
sekunder = flyte (str (tidsforskjell.total_sekunder ()))
return str (datetime.timedelta (sekunder = sekunder)).dele(".") [0]
def mon_net_connection (ping_freq = 2):
monitor_start_time = datetid.dato tid.nå()
motd = "Overvåking av nettverkstilkobling startet kl:" + str (monitor_start_time).dele(".") [0] +" Sender pingforespørsel om "+ str (ping_freq) +" sekunder "
skrive ut (motd)
med åpen (FIL, "a") som fil:
fil.skriv ("\ n")
fil.skriv (motd + "\ n")
mens det er sant:
hvis send_ping_request ():
tid.sove (ping_freq)
ellers:
nedetid = datetid.dato tid.nå()
fail_msg = "Nettverkstilkobling utilgjengelig på:" + str (nedetid).dele(".") [0]
skriv ut (fail_msg)
med åpen (FIL, "a") som fil:
fil.skriv (fail_msg + "\ n")
jeg = 0
mens ikke send_ping_request ():
tid.sove (1)
i + = 1
hvis jeg> = 3600:
jeg = 0
nå = datetime.dato tid.nå()
continous_message = "Nettverk utilgjengelig vedvarende ved:" + str (nå).dele(".") [0]
skriv ut (kontinuerlig_melding)
med åpen (FIL, "a") som fil:
fil.skriv (kontinuerlig_melding + "\ n")
oppetid = datetid.dato tid.nå()
uptime_message = "Nettverkstilkobling gjenopprettet ved:" + str (up_time).dele(".") [0]
nedetid = beregne tid (nedetid, oppetid)
_m = "Nettverkstilkobling var utilgjengelig for" + nedetid
skriv ut (oppetid_melding)
skrive ut (_m)
med åpen (FIL, "a") som fil:
fil.skriv (oppetid_melding + "\ n")
fil.skriv (_m + "\ n")
mon_net_connection ()
Hvis du kjører dette skriptet, får du en utdata som ligner på den som er vist nedenfor:
Konklusjon
Ved å bruke det ovennevnte skriptet kan vi overvåke når nettverkstilkoblingen går tapt og kontinuerlig logge den til den er tilgjengelig. Dette enkle skriptet er åpent for forbedringer. Juster gjerne koden for å passe dine behov og utvid den.
