Phenquestions
Ter aplicativos e dispositivos que precisam registrar, enviar e receber dados para o mundo externo é fundamental. Assim, ter uma ferramenta que permite monitorar quando sua rede cai pode ajudá-lo a solucionar problemas da rede ou interromper os aplicativos antes de enviar um monte de erros de registro.
No tutorial de hoje, construiremos um monitor de rede simples que monitora continuamente sua conectividade com a Internet, enviando solicitações de ping para um recurso externo. O script que criaremos também deve manter registros de quando a internet está fora do ar e a duração do tempo de inatividade:
Requisitos do Projeto
Para este projeto, vamos precisar apenas de:
- Noções básicas de programação Python
- Conhecimento básico de redes de computadores.
- Fique confortável ao usar o terminal.
Lógica de Projeto
Antes de mergulharmos na parte de codificação, vamos discutir e entender o que estamos tentando alcançar:
O que é rede ativa e inativa?
Quando falamos sobre o tempo de inatividade e atividade da rede, queremos dizer o período em que a conexão de rede fica totalmente indisponível e, portanto, não podemos nos comunicar com dispositivos fora de nossa rede. Quanto mais tempo a Internet ficar indisponível, maior será o tempo de inatividade.
Como determinar o tempo de inatividade
Agora que sabemos o que é o tempo de inatividade da Internet, você pode estar se perguntando: “como vamos determinar isso?”
Sem complicar nosso código, podemos usar o ping. Um ping é um método em que fazemos ping continuamente em um servidor confiável - talvez Cloudflare ou Google DNS - e então esperamos por uma resposta.
Se pingarmos o servidor e não houver resposta, observamos aquele horário específico e continuamos o ping até recebermos um ping e observarmos o horário.
Tendo a diferença de tempo, podemos notar quando a internet ficou fora do ar e por quanto tempo.
Também devemos ter cuidado ao executar ping em um único servidor, pois podemos confundir o ping erroneamente com um ataque DDoS, o que pode fazer com que nosso endereço IP seja bloqueado, o que produziria resultados negativos.
Aqui está um fluxograma que explica esse conceito:
Falar é fácil; vamos agora mergulhar no código que mostra como implementar essa lógica:
Agora me mostre o código
Como de costume, 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 de soquetes para enviar uma solicitação a um endereço IP externo na primeira função. Para este exemplo, usamos o endereço DNS público Cloudflare, que tem um tempo de atividade muito alto. Também passamos a porta e, como é um servidor DNS, usamos a porta 53.
Em seguida, verificamos se temos acesso ao diretório do arquivo de log e saímos se não tivermos acesso.
A próxima etapa é calcular o tempo que a conexão de rede está inativa. Por fim, envolvemos toda a funcionalidade em um loop, conforme mostrado no código a seguir.
soquete de importaçãotempo de importação
importar data e hora
importar os
import sys
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:
tomada.setdefaulttimeout (tempo limite)
s = socket.socket (socket.AF_INET, soquete.SOCK_STREAM)
s.conectar ((host, porta))
exceto OSError como erro:
retorna falso
senão:
s.perto()
retornar verdadeiro
def write_permission_check ():
tentar:
com aberto (FILE, "a") como arquivo:
passar
exceto OSError como erro:
imprimir ("Falha na criação do arquivo de log")
sys.saída()
finalmente:
passar
def calcule_time (iniciar, parar):
time_difference = stop - start
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.data hora.agora()
motd = "Monitoramento de conexão de rede iniciado em:" + str (monitor_start_time).dividir(".") [0] +" Enviando solicitação de ping em "+ str (ping_freq) +" segundos "
imprimir (motd)
com aberto (FILE, "a") como arquivo:
Arquivo.escrever ("\ n")
Arquivo.escrever (motd + "\ n")
enquanto verdadeiro:
se send_ping_request ():
Tempo.dormir (ping_freq)
senão:
down_time = datetime.data hora.agora()
fail_msg = "Conexão de rede indisponível em:" + str (down_time).dividir(".") [0]
imprimir (fail_msg)
com aberto (FILE, "a") como arquivo:
Arquivo.escrever (fail_msg + "\ n")
i = 0
enquanto não send_ping_request ():
Tempo.dormir (1)
i + = 1
se i> = 3600:
i = 0
agora = datetime.data hora.agora()
continous_message = "Incapacidade de rede persistente em:" + str (agora).dividir(".") [0]
imprimir (mensagem_contínua)
com aberto (FILE, "a") como arquivo:
Arquivo.escrever (mensagem_contínua + "\ n")
up_time = datetime.data hora.agora()
uptime_message = "Conectividade de rede restaurada em:" + str (up_time).dividir(".") [0]
down_time = calcule_time (down_time, up_time)
_m = "A conexão de rede estava indisponível por" + tempo de inatividade
imprimir (uptime_message)
imprimir (_m)
com aberto (FILE, "a") como arquivo:
Arquivo.escrever (uptime_message + "\ n")
Arquivo.escrever (_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á-la 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 expandi-lo.
