Script de Python para monitorear la conexión de red

La necesidad de tener nuestros dispositivos siempre conectados a Internet se está convirtiendo en una necesidad más básica que un privilegio adicional.

Es fundamental tener aplicaciones y dispositivos que necesiten registrar, enviar y recibir datos al mundo exterior. Por lo tanto, tener una herramienta que le permita monitorear cuando su red caiga puede ayudarlo a solucionar la red o detener las aplicaciones antes de enviar un montón de errores de registro.

En el tutorial de hoy, construiremos un monitor de red simple que monitoree continuamente su conectividad a Internet enviando solicitudes de ping a un recurso externo. El script que creamos también mantendrá registros de cuándo Internet está inactivo y la duración del tiempo de inactividad:

Requerimientos del proyecto

Para este proyecto, solo vamos a necesitar:

• Python Programming Basics
• Comprensión básica de las redes informáticas.
• Sea cómodo usando el terminal.

Lógica del proyecto

Antes de sumergirnos en la parte de codificación, discutamos y comprendamos lo que estamos tratando de lograr:

¿Qué es la red??

Cuando hablamos sobre la red y el tiempo de inactividad, nos referimos al período en que la conexión de red no está disponible y, por lo tanto, no podemos comunicarnos con dispositivos fuera de nuestra red. Cuanto más tiempo no esté disponible Internet, más tiempo será el tiempo de inactividad.

Cómo determinar el tiempo de inactividad

Ahora que sabemos qué es el tiempo de inactividad de Internet, es posible que se pregunte: “¿Cómo hacemos para determinarlo??"

Sin complicar nuestro código, podemos ir con ping. Un ping es un método en el que continuamente hacemos un servidor confiable, tal vez CloudFlare o Google DNS, y luego esperamos una respuesta.

Si hizo ping al servidor y no hay respuesta, observamos que el tiempo específico y continuamos haciendo ping hasta que recibamos un ping y anotemos el tiempo.

Teniendo la diferencia de tiempo, podemos tener en cuenta cuándo Internet estaba inactivo y por cuánto tiempo.

También debemos tener cuidado al hacer ping a un solo servidor porque podemos tener el ping falsamente equivocado como un ataque DDoS, lo que podría hacer que nuestra dirección IP se bloquee, lo que produciría resultados negativos.

Aquí hay un diagrama de flujo que explica este concepto:

Hablar es barato; Ahora vamos a sumergirnos en el código que muestra cómo implementar esta lógica:

Ahora muéstrame el código

Como de costumbre, en Python, comenzamos importando las bibliotecas requeridas. A continuación, creamos un archivo de registro en el directorio de trabajo actual.

Utilizamos la biblioteca Socket para enviar una solicitud a una dirección IP externa en la primera función. Para este ejemplo, utilizamos la dirección DNS pública de CloudFlare, que tiene un tiempo de actividad muy alto. También pasamos el puerto, y dado que es un servidor DNS, use el puerto 53.

Luego verificamos que tengamos acceso al directorio de archivos de registro y renunciamos si no tenemos acceso.

El siguiente paso es calcular la hora en que la conexión de red está baja. Finalmente, envolvemos toda la funcionalidad en un bucle, como se muestra en el código a continuación.

TOCKETOR DE IMPORTA
tiempo de importación
Importar DateTetime
importar sistema operativo
Sys de importación
Log_fname = "Red.registro"
File = OS.camino.unirse (OS.getCwd (), log_fname)
def send_ping_request (host = "1.1.1.1 ", puerto = 53, tiempo de espera = 3):
intentar:
enchufe.setDefaultTerout (Tiempo de espera)
s = enchufe.enchufe (enchufe.Af_inet, enchufe.Sock_stream)
s.Connect ((host, puerto))
Excepto Oserror como error:
falso retorno
demás:
s.cerca()
Devolver verdadero
Def write_permission_check ():
intentar:
con Open (archivo, "A") como archivo:
aprobar
Excepto Oserror como error:
imprimir ("Falló en la creación de archivo de registro")
sys.salida()
finalmente:
aprobar
def calculación_time (inicio, detener):
Time_difference = parar - iniciar
segundos = float (str (time_difference.Total_seconds ())))
return str (dateTime.Timedelta (segundos = segundos)).dividir(".") [0]
Def mon_net_connection (ping_freq = 2):
monitor_start_time = DateTime.fecha y hora.ahora()
MOTD = "Monitoreo de conexión de red se inició en:" + STR (monitor_start_time).dividir(".") [0] +" Enviar solicitud de ping en " + str (ping_freq) +" segundos "
Imprimir (MOTD)
con Open (archivo, "A") como archivo:
archivo.escribir ("\ n")
archivo.Escribir (MOTD + "\ n")
Mientras que es cierto:
Si send_ping_request ()::
tiempo.dormir (ping_freq)
demás:
down_time = dateTime.fecha y hora.ahora()
fail_msg = "Conexión de red no disponible en:" + str (down_time).dividir(".") [0]
imprimir (fail_msg)
con Open (archivo, "A") como archivo:
archivo.escribir (fail_msg + "\ n")
i = 0
mientras que no send_ping_request ()::
tiempo.dormir (1)
i += 1
Si i> = 3600:
i = 0
Ahora = DateTime.fecha y hora.ahora()
Contineous_message = "Network Unavailabilty persistente en:" + str (ahora).dividir(".") [0]
Imprimir (continuo_message)
con Open (archivo, "A") como archivo:
archivo.escribir (continuo_message + "\ n")
up_time = dateTime.fecha y hora.ahora()
Time_message = "Conectividad de red restaurada en:" + STR (UP_TIME).dividir(".") [0]
down_time = calculate_time (down_time, up_time)
_m = "La conexión de red no estaba disponible para" + down_time
Imprimir (Time_message)
Imprimir (_m)
con Open (archivo, "A") como archivo:
archivo.Escribir (Time_message + "\ n")
archivo.escribir (_m + "\ n")
mon_net_connection ()

Si ejecuta este script, obtendrá una salida similar a la que se muestra a continuación:

Conclusión

Usando el script anterior, podemos monitorear cuándo se pierde la conexión de red y registrarla constantemente hasta que esté disponible. Este script simple está abierto a mejoras. Siéntase libre de ajustar el código para que se ajuste a sus necesidades y expandirlo.