Script di monitoraggio del server Python

Lo script di monitoraggio del server Python consente di monitorare se il server o il computer sono attivi ed in esecuzione. Può mostrarti quanto tempo di inattività ha avuto il tuo computer o server. Utilizzeremo le prese del server per verificare se la porta specifica su un server è aperta o meno, il comando ping per monitorare un semplice computer normale e SSL per verificare se il particolare server richiede una connessione SSL o no. Per il monitoraggio del server, ho utilizzato il Visual Studio Code Interpreter Strumento.

Crea file python.Py

Apri l'interprete di Python e crea un nuovo file denominato server.Py e lo ha salvato in una posizione particolare dove è possibile accedere facilmente. Quando il file è stato creato, aggiungi alcuni comandi di importazione per importare pacchetti importanti come segue:

• PRESA: Per connettersi con diversi server su una determinata presa da una porta particolare
• SSL: Richiesto per l'avvolgimento della connessione socket
• Appuntamento: Usato per controllare a che ora il server era giù o attivo
• Salamoia: Utilizzato per salvare la cronologia dei tempi di giù del computer, oltre a propagare i dati da eseguire con questo programma

Società di importazione
Importa SSL
da DateTime Import DateTime
Importa sottaceto

Stiamo usando il piattaforma E sottoprocesso pacchetti, che ci diranno quale sistema operativo stiamo eseguendo, E.G., Unix O finestre.

Sottoprocesso di importazione
piattaforma di importazione

Crea una classe di server

Creiamo una classe chiamata Server() e costruito un primo metodo, che è un metodo del costruttore. Abbiamo aggiunto alcuni attributi per il server, E.G., Qualsiasi computer unix o normale. Diamo un'occhiata a ciascuno:

• Nome: Specificare il nome di un server
• Porta: il numero di porta a cui vogliamo connetterci
• Connessione: racconta il tipo di connessione, E.G., SSL o ping
• Priorità: Dicci la priorità del server, E.G., È possibile impostare avvisi se si imposta la priorità
• Storia: per mantenere l'elenco della cronologia dei server
• Mettere in guardia: Se vuoi inviare avvisi alla tua email

Class Server ():
def __init __ (self, nome, porta, connessione, priorità):
se stesso.nome = nome
se stesso.porta = porta
se stesso.connessione = connessione.inferiore()
se stesso.priorità = priorità.inferiore()
se stesso.storia = []
se stesso.Avviso = false

Crea un metodo per controllare la connessione

Quindi, per testare la connessione del server, abbiamo creato un altro metodo nella classe Server () denominata check_connection (). In questo metodo, dobbiamo definire tre variabili come:

• MSG: utilizzato per visualizzare un messaggio se la connessione stabilita o non riuscita è inizialmente vuota
• Successo: usato per dire se la connessione ha esito positivo o no
• Ora: otterrà la data e l'ora correnti durante il controllo della connessione

def check_connection (self):
msg = ""
Success = false
ora = datetime.Ora()

Ora scrivi il codice seguente nello stesso file e utilizzando il Prova dichiarazione, Stiamo controllando la connessione per diversi tipi di connessione dei server, E.G. semplice, ssl e ping. In questo Prova dichiarazione, Abbiamo un'istruzione IF che ha una connessione di pianura tipo. Creerà una connessione con il fornito nome e qualsiasi porta numero che hai fornito. Se la connessione ha esito positivo, genererà a messaggio di successo, e.G., MSG. Trasporterà il Successo variabile a VERO e nessun avviso verrà inviato all'e -mail. Abbiamo altro If Dichiarazione con un tipo di connessione diverso e nell'ultima istruzione IF abbiamo a ping () funzione chiamata. Nel Tranne la dichiarazione, Se la presa ha esaurito il tempo, una connessione viene rifiutata o qualsiasi altra cosa, visualizzerà a Messaggio di errore.

Tentativo:
se sé.Connection == "Plain":
PRESA.create_connection ((self.Nome, Self.porta), timeout = 10)
msg = f "self.il nome è attivo. Sulla porta self.porta con self.connessione"
successo = vero
se stesso.Avviso = false
Elif Self.Connection == "SSL":
SSL.wrap_socket (socket.create_connection (
(se stesso.Nome, Self.porta), timeout = 10))
msg = f "self.il nome è attivo. Sulla porta self.porta con self.connessione"
successo = vero
se stesso.Avviso = false
altro:
se sé.ping ():
msg = f "self.il nome è attivo. Sulla porta self.porta con self.connessione"
successo = vero
se stesso.Avviso = false
Tranne la presa.tempo scaduto:
msg = f "server: self.Nome timeout. Sulla porta self.porta"
Tranne (ConnectionRefusedError, ConnectionReseterror) come E:
msg = f "server: self.nome e "
Tranne l'eccezione come E:
msg = f "Nessun indizio??: e "

D'altra parte, se il stato di successo E mettere in guardia Sono Falso, lo cambierà in VERO e invia un mettere in guardia all'e -mail fornita e chiama il file create_history () funzione per creare un file storia.

Se successo == falso e sé.Alert == False:
# Invia avviso
se stesso.Avviso = vero
email_alert (self.nome, f "msg \ n ora", "[email protected] ")
se stesso.create_history (msg, successo, ora)

Definire un metodo per creare cronologia

Nel metodo create_history (), ne abbiamo aggiunti alcuni attributi con il massimo limite definito e se la storia il limite supera, lo farà eliminare quello più vecchio.

def create_history (self, msg, successo, ora):
history_max = 100
se stesso.storia.append ((msg, successo, ora))
Mentre len (sé.cronologia)> history_max:
se stesso.storia.pop (0)

Definire la funzione ping da connettersi

IL ping () La funzione pingrà il server o il computer. Se il ping è riuscito, emetterà vero e se la connessione fallito, tornerà Falso.

def ping (self):
Tentativo:
output = sottoprocesso.check_output ("ping - 1 ".formato ('n' se piattaforma.sistema(
).inferiore () == "Windows" else 'c', self.nome), shell = true, universal_newlines = true)
Se "irraggiungibile" in output:
restituire false
altro:
restituire vero
Tranne l'eccezione:
restituire false

Crea elenco di server

Ora dobbiamo assicurarci di gestire il Programma principale. IL If-Statement controllerà se si tratta del programma principale o no. IL Prova dichiarazione Volere carico il server File sottaceto Se esiste già. Se non esiste, il Tranne la dichiarazione otterrà un insieme Nuovo elenco di server. Per uno qualsiasi dei server, connessioni sarà controllato e la storia verrà salvata. D'altra parte, dobbiamo salva Nostro dati al sottaceto file usando il scarico dichiarazione.

Se __Name__ == "__main__":
Tentativo:
server = sottaceto.caricamento (aperto ("server.sottaceto "," rb ")
tranne:
server = [
Server ("reddit.com ", 80," pianura "," alto "),
Server ("msn.com ", 80," pianura "," alto "),
Server ("SMTP.gmail.com ", 465," ssl "," alto "),
Server ("192.168.1.164 ", 80," pianura "," alto "),
Server ("Yahoo.com ", 80," pianura "," alto "),
"
per il server nei server:
server.check_connection ()
Stampa (Len (server.storia))
Stampa (server.Storia [-1])
salamoia.dump (server, aperto ("server.sottaceto "," wb "))

L'output seguente verrà visualizzato durante l'esecuzione di questo file.

Crea file per l'aggiunta di informazioni

Crea un nuovo file denominato aggiungere.Py E importare Pacchetto Pickle e server di classe dal vecchio file server.Py. Questo file aprirà il file sottaceto e ti chiederà di aggiungere alcune informazioni aggiuntive sul server come il codice viene mostrato di seguito.

Importa sottaceto
dal server di importazione del server
server = sottaceto.caricamento (aperto ("server.sottaceto "," rb ")
Stampa ("Esempio per aggiungere server")
serverName = input ("Immettere il nome del server:")
porta = int (input ("Immettere un numero di porta come numero intero:"))
Connection = Input ("Immettere un tipo ping/pianura/ssl:")
priorità = input ("Immettere priorità alta/bassa:")
new_server = server (serverName, porta, connessione, priorità)
server.append (new_server)
salamoia.dump (server, aperto ("server.sottaceto "," wb "))

Quando esegui questo file, otterrai l'output di seguito e ti chiederà di aggiungere il nome del server, la porta, il tipo di ping e la priorità.

Mentre, quando si esegue il server.Py File di nuovo, otterrai le informazioni relative al vecchio server, nonché la cronologia del nuovo server che hai fornito nell'immagine sopra.

Crea file per avvisi Gmail

Ora crea un nuovo file denominato gmail.Py e importa alcuni pacchetti richiesti. Quindi crea un metodo chiamato email_alert () che crea un mettere in guardia per inviare il e-mail fornendo e -mail e parola d'ordine informazione.

Importa Smtplib
dall'email.Messaggio Importa EmailMessage
def email_alert (soggetto, corpo, a):
msg = emailMessage ()
MSG.set_content (corpo)
gmail_user = '[email protected]
gmail_password = 'get_app_password'
msg ['soggetto'] = soggetto
msg ['from'] = "[email protected] "
msg ['a'] = a
S = Smtplib.SMTP ('SMTP.gmail.com ', 587)
S.ehlo ()
S.starttls ()
S.Login (Gmail_User, Gmail_Password)
S.Send_Message (MSG)
S.esentato()
Se __Name__ == '__main__':
email_alert ("test", "https: // discord.GG/CAWW5QQ "," [email protected] ")

Ora vai al server.Py File e importa il email_alert () Metodo dal Gmail.Py File.

da Gmail Import email_alert

Puoi aggiungere il tuo indirizzo e-mail dove richiesto nel codice. Ora esegui il server.Py File e controlla l'output mostrato nel terminale dell'interprete di Python.

Crea un file per ottenere statistiche

Ora devi creare Un altro file Python chiamato get_stats.Py all'interno della stessa directory. Questo file ha importato il Classe server dal server.Py file. Il codice scritto di seguito esaminerà il nostro file sottaceto, che viene caricato e stampa la storia di ciascuno server e quanto ha quel particolare server Uptime.

Importa sottaceto
dal server di importazione del server
server = sottaceto.caricamento (aperto ("server.sottaceto "," rb ")
per il server nei server:
server_up = 0
Per punto nel server.storia:
se punto [1]:
server_up += 1
print (f "---------- \ n server.Nome è stato su server_up / len (server.cronologia) * 100 \ ntotal History: len (server.storia) \ n ------------ \ n ")

Quando esegui questo particolare file, vedrai una cronologia totale di ogni server e anche il loro tempo di attività.

Conclusione

Abbiamo provato e appreso con successo lo script di monitoraggio del server Python nel nostro interprete di codice Visual Studio per ottenere informazioni su più server.