Phenquestions
Het is van cruciaal belang om applicaties en apparaten te hebben die gegevens naar de buitenwereld moeten loggen, verzenden en ontvangen. Als u dus een tool heeft waarmee u kunt controleren wanneer uw netwerk uitvalt, kunt u problemen met het netwerk oplossen of de toepassingen stoppen voordat u een heleboel logfouten verzendt.
In de tutorial van vandaag zullen we een eenvoudige netwerkmonitor bouwen die voortdurend je internetverbinding bewaakt door ping-verzoeken naar een externe bron te sturen. Het script dat we zullen maken, houdt ook logboeken bij van wanneer het internet uitvalt en de duur van de downtime:
Projectvereisten
Voor dit project hebben we alleen nodig:
- Basisprincipes van Python-programmering
- Basiskennis van computernetwerken.
- Wees comfortabel bij het gebruik van de terminal.
Projectlogica
Voordat we in het coderingsgedeelte duiken, laten we bespreken en begrijpen wat we proberen te bereiken:
Wat is netwerk-up en downtime??
Als we het hebben over up- en downtime van het netwerk, bedoelen we de periode waarin de netwerkverbinding volledig niet beschikbaar is en we dus niet kunnen communiceren met apparaten buiten ons netwerk. Hoe langer het internet niet beschikbaar is, hoe langer de downtime.
Hoe downtime te bepalen?
Nu we weten wat downtime van internet is, vraagt u zich misschien af: "hoe gaan we dit bepalen?"?”
Zonder onze code ingewikkeld te maken, kunnen we gaan met ping. Een ping is een methode waarbij we continu een betrouwbare server pingen, misschien Cloudflare of Google DNS, en dan wachten op een reactie.
Als we de server pingen en er is geen reactie, noteren we die specifieke tijd en blijven we pingen totdat we een ping ontvangen en noteren we de tijd.
Met het tijdsverschil kunnen we zien wanneer het internet niet beschikbaar was en voor hoe lang.
We moeten ook voorzichtig zijn bij het pingen van een enkele server, omdat we de ping ten onrechte kunnen aanzien als een DDoS-aanval, waardoor ons IP-adres kan worden geblokkeerd, wat negatieve resultaten zou opleveren.
Hier is een stroomschema waarin dit concept wordt uitgelegd:
Praten is goedkoop; laten we nu in de code duiken die laat zien hoe deze logica kan worden geïmplementeerd:
Laat me nu de code zien
Zoals gewoonlijk beginnen we in Python met het importeren van de vereiste bibliotheken. Vervolgens maken we een logbestand aan in de huidige werkdirectory.
We gebruiken de socketbibliotheek om een verzoek te sturen naar een extern IP-adres in de eerste functie. Voor dit voorbeeld gebruiken we het openbare DNS-adres van Cloudflare, dat een zeer hoge uptime heeft. We geven ook de poort door, en aangezien het een DNS-server is, gebruik je poort 53.
We controleren dan of we toegang hebben tot de map met logbestanden en stoppen als we geen toegang hebben.
De volgende stap is het berekenen van de tijd dat de netwerkverbinding uitvalt. Ten slotte wikkelen we de volledige functionaliteit in een lus, zoals weergegeven in de onderstaande code.
stopcontact importerenimport tijd
datum/tijd importeren
importeer os
import systeem
LOG_FNAME = "netwerk.loggen"
BESTAND = os.pad.join(os.getcwd(), LOG_FNAME)
def send_ping_request(host="1 .).1.1.1", poort=53, time-out=3):
proberen:
stopcontact.standaardtime-out instellen (time-out)
s = stopcontact.stopcontact (stopcontact).AF_INET, stopcontact.SOCK_STREAM)
zo.verbinden((host,poort))
behalve OSError als fout:
retourneer False
anders:
zo.dichtbij()
retourneer True
def write_permission_check():
proberen:
met open(FILE, "a") als bestand:
voorbij lopen
behalve OSError als fout:
print("Aanmaken van logbestand mislukt")
sys.Uitgang()
Tenslotte:
voorbij lopen
def bereken_tijd (start, stop):
time_difference = stop - start
seconden = float(str(time_difference .).totaal_seconden()))
return str(datetime.tijddelta(seconden=seconden)).splitsen(".")[0]
def mon_net_connection(ping_freq=2):
monitor_start_time = datetime.datum Tijd.nu()
motd = "Bewaking netwerkverbinding gestart om: " + str(monitor_start_time).splitsen(".")[0] + " Ping-verzoek wordt verzonden in " + str(ping_freq) + " seconden"
afdrukken (motd)
met open(FILE, "a") als bestand:
het dossier.schrijven("\n")
het dossier.schrijven (motd + "\n")
terwijl waar:
if send_ping_request():
tijd.slaap(ping_freq)
anders:
down_time = datumtijd.datum Tijd.nu()
fail_msg = "Netwerkverbinding niet beschikbaar om: " + str(down_time).splitsen(".")[0]
print(fail_msg)
met open(FILE, "a") als bestand:
het dossier.schrijven (fail_msg + "\n")
ik = 0
terwijl niet send_ping_request():
tijd.slapen(1)
ik += 1
als ik >= 3600:
ik = 0
nu = datumtijd.datum Tijd.nu()
continous_message = "Netwerk niet beschikbaar Aanhoudend op: " + str(nu).splitsen(".")[0]
print(continu_bericht)
met open(FILE, "a") als bestand:
het dossier.schrijven (continu_bericht + "\n")
up_time = datumtijd.datum Tijd.nu()
uptime_message = "Netwerkverbinding hersteld om: " + str(up_time).splitsen(".")[0]
down_time = bereken_tijd (down_time, up_time)
_m = "Netwerkverbinding was niet beschikbaar voor " + down_time
print(uptime_message)
afdrukken(_m)
met open(FILE, "a") als bestand:
het dossier.schrijven (uptime_message + "\n")
het dossier.schrijven(_m + "\n")
mon_net_connection()
Als u dit script uitvoert, krijgt u een uitvoer die lijkt op die hieronder:
Conclusie
Met behulp van het bovenstaande script kunnen we controleren wanneer de netwerkverbinding wordt verbroken en deze constant loggen totdat deze beschikbaar is. Dit eenvoudige script staat open voor verbeteringen. Voel je vrij om de code aan je behoeften aan te passen en uit te breiden.
