Script de monitoreo del servidor de Python

El script de monitoreo del servidor de Python le permite monitorear si su servidor o computadora está activo y en ejecución. Puede mostrarle cuánto tiempo de inactividad tenía su computadora o servidor. Utilizaremos los sockets del servidor para verificar si el puerto específico en un servidor está abierto o no, el comando de ping para monitorear una computadora normal simple y el SSL para verificar si el servidor en particular requiere una conexión SSL o no. Para el monitoreo del servidor, he estado usando el Herramienta de intérprete de Código de Visual Studio.

Crear archivo python.py

Abra el intérprete de Python y cree un nuevo archivo llamado Servidor.py y lo guardó en una ubicación particular donde se puede acceder fácilmente. Cuando se haya creado el archivo, agregue algunos comandos de importación para importar paquetes importantes de la siguiente manera:

• Enchufe: Para conectarse con diferentes servidores en un determinado enchufe por un puerto en particular
• Ssl: Requerido para el envoltorio de la conexión al socket
• Fecha y hora: Se usa para verificar a qué hora estaba el servidor o activo
• Pepinillo: Utilizado para guardar el historial de la computadora de actividad y el tiempo de actividad, así como propagar los datos de la ejecución con este programa

TOCKETOR DE IMPORTA
importar SSL
desde la importación de fecha y hora de fecha y hora
encurtido de importación

Estamos usando el plataforma y subproceso paquetes, que nos dirán qué sistema operativo estamos ejecutando, e.gramo., Desastre o Windows.

importar subprocesos
plataforma de importación

Crear una clase de servidor

Creemos una clase llamada Servidor() y construyó un primer método, que es un método de constructor. Hemos agregado algunos atributos para el servidor, E.gramo., cualquier computadora UNIX o regular. Echemos un vistazo a cada uno:

• Nombre: especifique el nombre de un servidor
• Puerto: el número de puerto al que queremos conectarnos
• Conexión: dice el tipo de conexión, e.gramo., SSL o ping
• Prioridad: Cuéntanos la prioridad del servidor, e.gramo., Puede establecer alertas si establece prioridad
• Historia: para mantener la lista del historial del servidor
• Alerta: Si desea enviar alertas a su correo electrónico

Class Server ():
def __init __ (self, nombre, puerto, conexión, prioridad):
ser.nombre = nombre
ser.puerto = puerto
ser.conexión = conexión.más bajo()
ser.prioridad = prioridad.más bajo()
ser.historia = []
ser.alerta = falso

Crear un método para verificar la conexión

Entonces, para probar la conexión del servidor, hemos creado otro método en la clase Server () llamado check_connection (). En este método, tenemos que definir tres variables como:

• Machista: Se utiliza para mostrar un mensaje si la conexión se establece o falló que inicialmente está vacía
• Éxito: Se usa para saber si la conexión es exitosa o no
• Ahora: Obtendrá la fecha y hora actuales al verificar la conexión

Def check_connection (self):
msg = ""
éxito = falso
Ahora = DateTime.ahora()

Ahora escriba el siguiente código en el mismo archivo y usando el declaración de prueba, Estamos comprobando la conexión para diferentes tipos de conexión de servidores, E.gramo. simple, ssl y ping. En esto declaración de prueba, Tenemos si la declaración tiene una conexión de plano tipo. Creará una conexión con el proporcionado nombre y cualquier puerto número que proporcionó. Si la conexión es exitosa, generará un mensaje de éxito, mi.gramo., machista. Volverá el Éxito variable a Verdadero y no se enviará ninguna alerta al correo electrónico. Tenemos más si la declaración con un tipo de conexión diferente, y en la última declaración IF tenemos un silbido() función llamada. En el excepto la declaración, Si el socket se ha quedado sin tiempo, se rechazan una conexión, o cualquier otra cosa, mostrará un mensaje de falla.

intentar:
Si uno mismo.conexión == "simple":
enchufe.create_connection ((self.nombre, yo.puerto), tiempo de espera = 10)
msg = f "yo.el nombre está arriba. En el puerto yo.puerto con yo.conexión"
éxito = verdadero
ser.alerta = falso
Elif yo.conexión == "SSL":
ssl.wrap_socket (socket.create_connection (
(ser.nombre, yo.puerto), tiempo de espera = 10))
msg = f "yo.el nombre está arriba. En el puerto yo.puerto con yo.conexión"
éxito = verdadero
ser.alerta = falso
demás:
Si uno mismo.silbido():
msg = f "yo.el nombre está arriba. En el puerto yo.puerto con yo.conexión"
éxito = verdadero
ser.alerta = falso
Excepto el zócalo.se acabó el tiempo:
msg = f "servidor: self.Nombre Tiempo de espera. En el puerto yo.puerto"
Excepto (ConnectionRefusedError, ConnectionResetError) como E:
msg = f "servidor: self.nombre e "
Excepto la excepción como E:
msg = f "sin pista??: e "

Por otro lado, si el estado de éxito y alerta son FALSO, Lo cambiará a Verdadero y enviar un alerta al correo electrónico proporcionado y llame al create_history () función para crear un historia.

Si éxito == falso y yo.alerta == falso:
# Enviar alerta
ser.alerta = verdadero
email_alert (yo.Nombre, f "msg \ n ahora", "[email protected] ")
ser.create_history (msg, éxito, ahora)

Definir un método para crear historia

En el método create_history (), Hemos agregado algunos atributos con máximo límite definido, y si la historia límite excede, va a borrar el mayor.

Def create_history (self, msg, éxito, ahora):
History_max = 100
ser.historia.append ((msg, éxito, ahora))
Mientras Len (yo mismo.Historia)> History_max:
ser.historia.Pop (0)

Definir la función de ping para conectarse

El silbido() la función hará ping al servidor o la computadora. Si el ping es exitoso, emitirá verdadero, y si la conexión fallido, Volverá FALSO.

Def ping (yo):
intentar:
salida = subprocesos.check_output ("ping - 1 ".formato ('n' si la plataforma.sistema(
).Lower () == "Windows" Else 'C', self.nombre), shell = true, universal_newlines = true)
Si 'inalcanzable' en la salida:
falso retorno
demás:
Devolver verdadero
Excepto la excepción:
falso retorno

Crear lista de servidores

Ahora tenemos que asegurarnos de que estamos ejecutando el programa principal. El Si estaticar verificará si es el programa principal o no. El declaración de prueba voluntad carga el servidor archivo de pepinillo Si ya existe. Si no existe, el excepto la declaración obtendrá un todo lista nueva de servidores. Para cualquiera de los servidores, conexión será comprobado y la historia se salvará. Por otro lado, tenemos que ahorrar nuestro datos al pepinillo archivo utilizando el vertedero declaración.

Si __name__ == "__main__":
intentar:
servidores = encurtido.Cargar (Abrir ("servidores.Pickle "," rb "))
excepto:
servidores = [
Servidor ("Reddit.com ", 80," Plain "," High "),
Servidor ("MSN.com ", 80," Plain "," High "),
Servidor ("SMTP.gmail.com ", 465," ssl "," alto "),
Servidor ("192.168.1.164 ", 80," Plain "," High "),
Servidor ("Yahoo.com ", 80," Plain "," High "),
]
para servidor en servidores:
servidor.verifica la conexión()
Imprimir (Len (servidor.historia))
servidor de impresión.Historia [-1])
pepinillo.volcado (servidores, abrir ("servidores.Pickle "," WB "))

Se mostrará la salida a continuación mientras ejecuta este archivo.

Crear archivo para agregar información

Crea un nuevo archivo llamado agregar.py y importar Packle Packle y servidor de clase desde el archivo anterior Servidor.py. Este archivo abrirá el archivo Pickle y le pedirá que agregue información adicional sobre el servidor a medida que se muestra a continuación.

encurtido de importación
Desde el servidor de importación del servidor
servidores = encurtido.Cargar (Abrir ("servidores.Pickle "," rb "))
Imprimir ("Ejemplo para agregar servidor")
servername = input ("Ingrese el nombre del servidor:")
puerto = int (input ("Ingrese un número de puerto como entero:"))
conexión = entrada ("Ingrese un tipo de ping/slsl:")
prioridad = entrada ("Ingrese la prioridad alta/baja:")
new_server = servidor (servidor, puerto, conexión, prioridad)
servidor.append (new_server)
pepinillo.volcado (servidores, abrir ("servidores.Pickle "," WB "))

Cuando ejecute este archivo, obtendrá la siguiente salida y le pedirá que agregue el nombre del servidor, el puerto, el tipo de ping y la prioridad.

Mientras que cuando ejecuta el servidor.PY File nuevamente, obtendrá la información sobre el servidor antiguo, así como el historial del nuevo servidor que ha proporcionado en la imagen anterior.

Crear archivo para alertas de Gmail

Ahora cree un nuevo archivo con nombre gmail.py e importar algunos paquetes requeridos. Luego crea un método nombrado alerta de correo() Eso crea un alerta Para enviar el correo electrónico mientras proporciona correo electrónico y contraseña información.

Importar SMTPLIB
desde el e-mail.Mensaje Importar correo electrónico Message
Def CORREA ELECH_ALERT (sujeto, cuerpo, a):
msg = correo electrónicoMessage ()
machista.set_content (cuerpo)
gmail_user = '[email protected] '
gmail_password = 'get_app_password'
msg ['sujeto'] = sujeto
msg ['from'] = "[email protected] "
msg ['a'] = a
S = SMTPLIB.SMTP ('SMTP.gmail.com ', 587)
s.ehlo ()
s.starttls ()
s.Iniciar sesión (gmail_user, gmail_password)
s.send_message (msg)
s.abandonar()
Si __name__ == '__main__':
email_alert ("prueba", "https: // discord.GG/CAWW5QQ "," [email protected] ")

Ahora ve al Servidor.archivo py e importar el alerta de correo() Método del Gmail.archivo py.

Desde Gmail Import Correo electrónico_alert

Puedes agregar tu dirección de correo electrónico donde sea necesario en el código. Ahora corre el Servidor.py archivo y verifique la salida que se muestra en el terminal del intérprete de Python.

Crear un archivo para obtener estadísticas

Ahora tienes que crear Otro archivo de Python llamado Get_stats.py Dentro del mismo directorio. Este archivo ha importado el Clase de servidor desde el Servidor.py archivo. El código escrito a continuación buscará nuestro archivo de encurtido, que se carga y imprimir la historia de cada servidor y cuanto tiene ese servidor en particular tiempo de actividad.

encurtido de importación
Desde el servidor de importación del servidor
servidores = encurtido.Cargar (Abrir ("servidores.Pickle "," rb "))
para servidor en servidores:
server_up = 0
Para el punto en el servidor.historia:
Si el punto [1]:
server_up += 1
imprimir (f "---------- \ n servidor.el nombre ha estado server_up / len (servidor.Historia) * 100 \ ntotal History: Len (servidor.historia) \ n ---------- \ n ")

Cuando ejecute este archivo en particular, verá un historial total de cada servidor y su tiempo de actividad también.

Conclusión

Hemos probado y aprendido con éxito el script de monitoreo de Python Server en nuestro intérprete de código de Visual Studio para obtener información sobre varios servidores.