Phenquestions
Il est essentiel de disposer d'applications et d'appareils qui doivent enregistrer, envoyer et recevoir des données vers le monde extérieur. Ainsi, avoir un outil qui vous permet de surveiller lorsque votre réseau tombe en panne peut vous aider à dépanner le réseau ou à arrêter les applications avant d'envoyer un tas d'erreurs de journal.
Dans le didacticiel d'aujourd'hui, nous allons créer un moniteur réseau simple qui surveille en permanence votre connectivité Internet en envoyant des requêtes ping à une ressource externe. Le script que nous allons créer conservera également des journaux des pannes d'Internet et de la durée de la panne :
Exigences du projet
Pour ce projet, nous n'aurons besoin que de :
- Bases de la programmation Python
- Compréhension de base des réseaux informatiques.
- Soyez à l'aise avec le terminal.
Logique du projet
Avant de plonger dans la partie codage, discutons et comprenons ce que nous essayons de réaliser :
Qu'est-ce que le temps de fonctionnement et d'arrêt du réseau?
Lorsque nous parlons de temps de fonctionnement et d'indisponibilité du réseau, nous entendons la période pendant laquelle la connexion réseau est entièrement indisponible et, par conséquent, nous ne pouvons pas communiquer avec des appareils en dehors de notre réseau. Plus Internet est indisponible, plus le temps d'arrêt est long.
Comment déterminer les temps d'arrêt
Maintenant que nous savons ce qu'est le temps d'arrêt d'Internet, vous vous demandez peut-être « comment allons-nous le déterminer ??"
Sans compliquer notre code, nous pouvons aller avec ping. Un ping est une méthode où nous pingons en continu un serveur fiable, peut-être Cloudflare ou Google DNS, puis attendons une réponse.
Si nous pingons le serveur et qu'il n'y a pas de réponse, nous notons cette heure spécifique et continuons à pinger jusqu'à ce que nous recevions un ping et notons l'heure.
Ayant le décalage horaire, nous pouvons noter quand Internet était en panne et pendant combien de temps.
Nous devons également faire attention lors du ping d'un seul serveur car nous pouvons avoir le ping faussement confondu avec une attaque DDoS, ce qui pourrait provoquer le blocage de notre adresse IP, ce qui produirait des résultats négatifs.
Voici un organigramme expliquant ce concept :
Parler n'est pas cher; plongeons maintenant dans le code montrant comment implémenter cette logique :
Maintenant, montre-moi le code
Comme d'habitude, en Python, on commence par importer les librairies requises. Ensuite, nous créons un fichier journal dans le répertoire de travail actuel.
Nous utilisons la bibliothèque socket pour envoyer une requête à une adresse IP externe dans la première fonction. Pour cet exemple, nous utilisons l'adresse DNS publique Cloudflare, qui a un temps de disponibilité très élevé. On passe aussi le port, et comme c'est un serveur DNS, on utilise le port 53.
Nous vérifions ensuite que nous avons accès au répertoire du fichier journal et quittons si nous n'avons pas accès.
L'étape suivante consiste à calculer le temps pendant lequel la connexion réseau est interrompue. Enfin, nous enveloppons toute la fonctionnalité dans une boucle, comme indiqué dans le code ci-dessous.
socket d'importationheure d'importation
date/heure d'importation
importer le système d'exploitation
importer le système
LOG_FNAME = "réseau.Journal"
FICHIER = os.chemin.rejoindre (os.getcwd(), LOG_FNAME)
def send_ping_request(host="1.1.1.1", port=53, délai d'attente=3) :
essayer:
prise.setdefaulttimeout(timeout)
s = prise.prise (prise.AF_INET, prise.SOCK_STREAM)
s.connecter ((hôte, port))
sauf OSError comme erreur :
retourner Faux
autre:
s.Fermer()
retourner vrai
def write_permission_check() :
essayer:
avec open(FILE, "a") comme fichier :
passe
sauf OSError comme erreur :
print("La création du fichier journal a échoué")
système.sortir()
finalement:
passe
def calculate_time(start, stop):
time_difference = arrêter - démarrer
secondes = float(str(time_difference.total_seconds()))
return str(dateheure.timedelta(secondes=secondes)).diviser(".")[0]
def mon_net_connection(ping_freq=2) :
monitor_start_time = datetime.dateheure.à présent()
motd = "La surveillance de la connexion réseau a commencé à : " + str(monitor_start_time).diviser(".")[0] + " Envoi d'une requête ping en " + str(ping_freq) + " secondes"
imprimer (motd)
avec open(FILE, "a") comme fichier :
déposer.écrire("\n")
déposer.écrire(motd + "\n")
tant que vrai :
si send_ping_request() :
temps.dormir(ping_freq)
autre:
down_time = dateheure.dateheure.à présent()
fail_msg = "Connexion réseau non disponible à : " + str(down_time).diviser(".")[0]
imprimer(fail_msg)
avec open(FILE, "a") comme fichier :
déposer.écrire (échec_msg + "\n")
je = 0
sans envoyer_ping_request() :
temps.dormir(1)
je += 1
si je >= 3600 :
je = 0
maintenant = dateheure.dateheure.à présent()
continous_message = "Indisponibilité du réseau persistante à : " + str(maintenant).diviser(".")[0]
imprimer (message_continu)
avec open(FILE, "a") comme fichier :
déposer.écrire (message_continu + "\n")
up_time = datetime.dateheure.à présent()
uptime_message = "Connectivité réseau restaurée à : " + str(up_time).diviser(".")[0]
down_time = calculate_time(down_time, up_time)
_m = "La connexion réseau était indisponible pendant " + down_time
imprimer(uptime_message)
imprimer(_m)
avec open(FILE, "a") comme fichier :
déposer.écrire(uptime_message + "\n")
déposer.écrire(_m + "\n")
mon_net_connection()
Si vous exécutez ce script, vous obtiendrez une sortie similaire à celle illustrée ci-dessous :
Conclusion
En utilisant le script ci-dessus, nous pouvons surveiller lorsque la connexion réseau est perdue et la consigner en permanence jusqu'à ce qu'elle soit disponible. Ce script simple est ouvert aux améliorations. N'hésitez pas à ajuster le code en fonction de vos besoins et à le développer.
