Script python pour surveiller la connexion réseau

La nécessité d'avoir nos appareils toujours connectés à Internet devient de plus en plus un besoin fondamental qu'un privilège supplémentaire.

Avoir des applications et des appareils qui doivent enregistrer, envoyer et recevoir des données dans le monde extérieur est essentiel. Ainsi, avoir un outil qui vous permet de surveiller lorsque votre réseau tombe peut vous aider à dépanner le réseau ou à arrêter les applications avant d'envoyer un tas d'erreurs de journal.

Dans le tutoriel d'aujourd'hui, nous créerons un moniteur réseau simple qui surveille continuellement votre connectivité Internet en envoyant des demandes de ping à une ressource externe. Le script que nous créerons doit également conserver les journaux de la fin de l'Internet et de la durée du temps d'arrêt:

Exigences du projet

Pour ce projet, nous n'aurons besoin que:

• Python Programming Basics
• Compréhension de base des réseaux informatiques.
• Être à l'aise d'utiliser le terminal.

Logique du projet

Avant de plonger dans la partie de codage, discutons et comprenons ce que nous essayons de réaliser:

Qu'est-ce que le réseau vers le haut et les temps d'arrêt?

Lorsque nous parlons de temps de réduction du réseau, nous entendons la période où la connexion du réseau est entièrement indisponible, et donc, nous ne pouvons pas communiquer avec des appareils à l'extérieur de notre réseau. Plus Internet n'est pas disponible, plus le temps d'arrêt est long.

Comment déterminer les temps d'arrêt

Maintenant que nous savons ce qu'est les temps d'arrêt Internet, vous vous demandez peut-être: «Comment pouvons-nous le déterminer?"

Sans compliquer notre code, nous pouvons aller avec Ping. Un ping est une méthode où nous pingons en permanence un serveur fiable - peut-être CloudFlare ou Google DNS, puis attend une réponse.

Si nous cinglons le serveur et qu'il n'y a pas de réponse, nous notons ce temps spécifique et continuons à faire un ping jusqu'à ce que nous recevions un ping et notez l'heure.

Ayant le décalage horaire, nous pouvons noter quand Internet était en panne et pendant combien de temps.

Nous devons également être prudents lors du ping à un seul serveur, car nous pouvons se tromper faussement en ping comme une attaque DDOS, ce qui pourrait entraîner un bloquer notre adresse IP, ce qui produirait des résultats négatifs.

Voici un tableau de flux expliquant ce concept:

Parler n'est pas cher; Plongeons maintenant dans le code montrant comment implémenter cette logique:

Maintenant, montrez-moi le code

Comme d'habitude, à Python, nous commençons par importer les bibliothèques requises. Ensuite, nous créons un fichier journal dans le répertoire de travail actuel.

Nous utilisons la bibliothèque Socket pour envoyer une demande à une adresse IP externe dans la première fonction. Pour cet exemple, nous utilisons l'adresse DNS publique CloudFlare, qui a une hausse très élevée. Nous passons également le port, et comme il s'agit d'un serveur DNS, utilisons le port 53.

Nous vérifions ensuite que nous avons accès au répertoire du fichier journal et nous arrêtons si nous n'avons pas accès.

L'étape suivante consiste à calculer l'heure à laquelle la connexion réseau est en panne. Enfin, nous enroulons la fonctionnalité entière dans une boucle, comme indiqué dans le code ci-dessous.

socket d'importation
heure d'importation
Importer DateTime
Importer un système d'exploitation
importer sys
Log_fname = "réseau.enregistrer"
Fichier = os.chemin.rejoindre (OS.getCwd (), log_fname)
def send_ping_request (host = "1.1.1.1 ", port = 53, temps mort = 3):
essayer:
prise.setDefaultTimeout (Timeout)
s = socket.prise.Af_inet, socket.Sock_stream)
s.connect ((hôte, port))
Sauf Oseror comme erreur:
retourner faux
autre:
s.fermer()
Retour vrai
def write_permission_check ():
essayer:
avec open (fichier, "a") en tant que fichier:
passer
Sauf Oseror comme erreur:
print ("La création de fichiers journaux a échoué")
système.sortie()
enfin:
passer
Def calcul_time (start, stop):
Time_différence = stop - démarrer
secondes = float (str (Time_différence.total_seconds ()))
return Str (DateTime.Timedelta (secondes = secondes)).diviser(".") [0]
def mon_net_connection (ping_freq = 2):
Monitor_Start_time = DateTime.DateTime.maintenant()
Motd = "La surveillance des connexions réseau a commencé à:" + str (monitor_start_time).diviser(".") [0] +" Envoi de la demande de ping dans "+ str (ping_freq) +" secondes "
Imprimer (Motd)
avec open (fichier, "a") en tant que fichier:
déposer.écrire ("\ n")
déposer.écrire (Motd + "\ n")
Bien que vrai:
Si send_ping_request ():
temps.Sleep (Ping_freq)
autre:
down_time = datetime.DateTime.maintenant()
fail_msg = "Connexion réseau indisponible à:" + str (down_time).diviser(".") [0]
print (fail_msg)
avec open (fichier, "a") en tant que fichier:
déposer.écrire (fail_msg + "\ n")
i = 0
Bien que non Send_ping_request ():
temps.sommeil (1)
i + = 1
Si i> = 3600:
i = 0
maintenant = datetime.DateTime.maintenant()
contines_message = "Réseau inconnu persistant à:" + str (maintenant).diviser(".") [0]
imprimer (continu_message)
avec open (fichier, "a") en tant que fichier:
déposer.écrire (continu_message + "\ n")
up_time = datetime.DateTime.maintenant()
UPtime_Message = "Connectivité réseau restaurée à:" + str (up_time).diviser(".") [0]
down_time = calcul_time (down_time, up_time)
_m = "La connexion réseau n'était pas disponible pour" + down_time
imprimer (Uptime_Message)
imprimer (_m)
avec open (fichier, "a") en tant que 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 ci-dessous:

Conclusion

En utilisant le script ci-dessus, nous pouvons surveiller lorsque la connexion réseau est perdue et la enregistrer constamment 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 de le développer.