Script Python para monitorar a conexão de rede

A necessidade de ter nossos dispositivos sempre conectados à Internet está se tornando mais uma necessidade básica do que um privilégio adicional.

Ter aplicativos e dispositivos que precisam registrar, enviar e receber dados para o mundo exterior é crítico. Assim, ter uma ferramenta que permite monitorar quando sua rede diminui pode ajudá -lo a solucionar a rede ou interromper os aplicativos antes de enviar vários erros de log.

No tutorial de hoje, criaremos um monitor de rede simples que monitora continuamente sua conectividade à Internet enviando solicitações de ping para um recurso externo. O script que criaremos também deve manter os registros de quando a Internet estiver baixa e a duração do tempo de inatividade:

Requisitos do projeto

Para este projeto, só precisaremos:

• Básico de programação Python
• Entendimento básico das redes de computadores.
• Fique confortável usando o terminal.

Lógica do projeto

Antes de mergulharmos na parte da codificação, vamos discutir e entender o que estamos tentando alcançar:

O que é rede para cima e de inatividade?

Quando conversamos sobre o Network Up and inative, queremos dizer o período em que a conexão de rede é totalmente indisponível e, portanto, não podemos nos comunicar com dispositivos fora de nossa rede. Quanto mais a internet não está disponível, mais tempo o tempo de inatividade.

Como determinar o tempo de inatividade

Agora que sabemos o que é o tempo de inatividade na Internet, você pode estar se perguntando: “Como vamos determinar?”

Sem complicar nosso código, podemos ir com ping. Um ping é um método em que continuamente pinamos um servidor confiável-talvez CloudFlare ou Google DNS-e depois aguardamos uma resposta.

Se formarmos o servidor e não houver resposta, observamos esse tempo específico e continuamos a ping até recebermos um ping e observarmos a hora.

Tendo a diferença de horário, podemos observar quando a internet foi inativa e por quanto tempo.

Também temos que ter cuidado ao fazer um único servidor, porque podemos ter o ping falsamente confundido como um ataque de DDoS, o que pode fazer com que nosso endereço IP seja bloqueado, o que produziria resultados negativos.

Aqui está um fluxograma explicando este conceito:

Falar é fácil; Vamos agora mergulhar no código mostrando como implementar esta lógica:

Agora me mostre o código

Como sempre, em Python, começamos importando as bibliotecas necessárias. Em seguida, criamos um arquivo de log no diretório de trabalho atual.

Usamos a biblioteca do soquete para enviar uma solicitação para um endereço IP externo na primeira função. Para este exemplo, usamos o endereço DNS público do CloudFlare, que tem um tempo de atividade muito alto. Também passamos pela porta e, como é um servidor DNS, use a porta 53.

Em seguida, verificamos se temos acesso ao diretório de arquivos de log e desistimos se não tivermos acesso.

O próximo passo é calcular o tempo em que a conexão de rede está inativa. Finalmente, embrulhamos toda a funcionalidade em um loop, como mostrado no código abaixo.

soquete de importação
tempo de importação
importar datetime
OS de importação
Importar sistemas
Log_fname = "Rede.registro"
Arquivo = os.caminho.Junte -se (OS.getcwd (), log_fname)
def send_ping_request (host = "1.1.1.1 ", porta = 53, tempo limite = 3):
tentar:
soquete.setDefaultTimeout (tempo limite)
s = soquete.soquete (soquete.Af_inet, soquete.Sock_stream)
s.Connect ((host, porta))
Exceto OSerror como erro:
retorna falso
outro:
s.fechar()
retornar verdadeiro
def write_permission_check ():
tentar:
com open (arquivo, "a") como arquivo:
passar
Exceto OSerror como erro:
print ("Falha na criação do arquivo de log")
sys.saída()
finalmente:
passar
def calcular_time (start, pare):
time_difference = pare - iniciar
segundos = float (str (time_difference.total_seconds ()))
Retornar STR (DATETIME.timedelta (segundos = segundos)).dividir(".") [0]
def mon_net_connection (ping_freq = 2):
monitor_start_time = datetime.data hora.agora()
MOTD = "O monitoramento da conexão de rede começou em:" + str (monitor_start_time).dividir(".") [0] +" enviando solicitação de ping em " + str (ping_freq) +" segundos "
Impressão (MOTD)
com open (arquivo, "a") como arquivo:
arquivo.escreva ("\ n")
arquivo.Write (MOTD + "\ n")
enquanto é verdade:
Se send_ping_request ():
tempo.sono (ping_freq)
outro:
Down_time = DateTime.data hora.agora()
Fail_msg = "Conexão de rede não está disponível em:" + str (Down_time).dividir(".") [0]
Imprimir (Fail_MSG)
com open (arquivo, "a") como arquivo:
arquivo.Write (Fail_MSG + "\ n")
i = 0
enquanto não send_ping_request ():
tempo.sono (1)
i += 1
Se i> = 3600:
i = 0
agora = datetime.data hora.agora()
Continuous_Message = "Rede de falta de alcance persistente em:" + str (agora).dividir(".") [0]
Imprimir (continuação_message)
com open (arquivo, "a") como arquivo:
arquivo.Write (continuação_message + "\ n")
up_time = DateTime.data hora.agora()
uptime_message = "conectividade de rede restaurada em:" + str (up_time).dividir(".") [0]
Down_time = calcular_time (Down_time, up_time)
_m = "A conexão de rede não estava disponível para" + Down_time
Imprimir (Uptime_Message)
Imprimir (_m)
com open (arquivo, "a") como arquivo:
arquivo.Write (UpTime_Message + "\ n")
arquivo.Escreva (_m + "\ n")
mon_net_connection ()

Se você executar este script, obterá uma saída semelhante à mostrada abaixo:

Conclusão

Usando o script acima, podemos monitorar quando a conexão de rede é perdida e registrá -lo constantemente até que esteja disponível. Este script simples está aberto a melhorias. Sinta -se à vontade para ajustar o código para atender às suas necessidades e expandir nele.