Ping wird an mehrere Ziele gesendet. Wenn 90% NG sind, wird dies als Fehler gewertet und E-Mails werden gesendet (Google Mail). Wenn Ping für die angegebene Anzahl von Malen hintereinander in Ordnung ist, wird die Wiederherstellung beurteilt.
Die erste Quelle ist Multithread, aber ich verstehe es nicht wirklich, deshalb bin ich mir nicht sicher, warum es funktioniert. Es ist auch die falsche Quelle, da es definitiv Fehler hat.
Das Programm, das keine Fehler haben sollte, wird in der zweiten Hälfte beschrieben. Es ist kein Multithreading, sondern Multi-Processing in der zweiten Hälfte. 29.12.2016 Behoben: Es gab einen Fehler, also habe ich ihn behoben. Weitere Informationen zur zweiten Hälfte des Programms finden Sie in den Kommentaren in der Quelle.
Dann ist es die Erklärung der falschen Quelle. Vorerst ist es Import.
import pandas as pd
import smtplib
import os, platform
import threading
Als nächstes folgt die Funktion zum Senden von Google Mail. Beim Senden von Google Mail müssen Sie den POP-Zugriff in Ihrem Konto aktivieren, um den Zugriff auf weniger sichere Apps zu ermöglichen. Wenn Sie suchen, finden Sie einen freundlichen Kommentar mit einem angehängten GUI-Bildschirm, sodass ich die Details Ihnen überlassen werde.
def sendGmail(text):
user = '****@gmail.com' # username
password = '******' # password
to = ['****@gmail.com'] # your favorite mail address
sub = 'mail title'
msg = '''From: %s\nTo: %s\nSubject: %s\n\n%s
''' % (user, ','.join(to), sub, text)
server = smtplib.SMTP_SSL("smtp.gmail.com", 465)
server.ehlo()
server.login(user, password)
server.sendmail(user, to, msg)
server.close()
Als nächstes folgt die Funktion zum Senden von Ping. log ist ein DataFrame. Es muss kein Datenrahmen sein, aber ich bin daran gewöhnt, weil ich daran gewöhnt bin. Es gibt viele Argumente, um das Ping-Ergebnis zu speichern, und dies ist der Teil, den ich für schmutzig halte.
def ping(address, current_position, log):
ping_str = '-n 1' if platform.system().lower() == 'windows' else '-c 1'
response = os.system('ping ' + ping_str + ' ' + address)
if response == 1:
log[address][current_position] = 1
Weiter ist die Hauptfunktion. Nacheinander wird das Ergebnis des Pings in den als Protokoll bezeichneten Datenrahmen geschrieben. Jedes Mal, wenn 700 Punkte aus dem letzten Protokoll zurückverfolgt werden und 600 oder mehr Ping-Fehler auftreten, wird die E-Mail übersprungen.
if __name__ == '__main__':
domain_list = ['***address***'] # your favorite address
log = pd.DataFrame(0, index=range(60 * 60), columns=domain_list)
#Erstellen Sie vorerst einen großen DataFrame.
current_position = 0
sum_of_seconds = 0
sendGmail('tool has started.')
while True:
text = []
for address in domain_list:
p = threading.Thread(target=ping, args=(address, current_position, log))
p.start()
sum_error = 0
for i in range(700):#Ich halte das für ineffizient
sum_error += log.ix[current_position - i if current_position >= i else 60 * 15 - (i - current_position), address]
if sum_error > 600:
text.append(address)
if (sum_of_seconds % 600 == 0) and (text != []):
sendGmail(text)
current_position += 1
if current_position >= 60 * 15:
current_position = 0
sum_of_seconds += 1
time.sleep(1)
Am Tag nachdem ich die obige Quelle geschrieben hatte, dachte ich, dass Multiverarbeitung besser wäre, also schrieb ich sie neu. Ich fand den Diktattyp zum ersten Mal nützlich.
Erstens ist der Google Mail-Sendeteil derselbe. Als nächstes wurde die Ping-Übertragung wie folgt überarbeitet.
import multiprocessing as mp
def ping(address, result):
ping_str = '-n 1' if platform.system().lower() == 'windows' else '-c 1'
response = subprocess.call('ping '+ ping_str + ' '+address)
if response = 1:
result[address] = 1
else:
result[address] = 0
Ergebnis ist vom Typ dikt. Später werden wir Multi-Processing machen. Was Ping betrifft, scheint subprocess.call besser zu sein als os.system, daher schreibe ich es ohne Verständnis neu.
Als nächstes folgt die Hauptfunktion, die wie folgt lautet.
if __name__ == '__main__':
manager = mp.Manager()
current_position = 0
bottom = 60*60
evaluate_range = 5 # x5
recover_range = 2 #10
evaluate_ratio = 0.9
before_result = pd.Series()
act_num = 0
domain_list = ['***', '****']
log = pd.DataFrame(0, index=range(bottom), columns=domain_list)
#Es definiert einen DataFrame, der das Ergebnis nach dem Ping speichert.
while True:
proc = [] #Für die Mehrfachverarbeitung
result = manager.dict() #Definieren Sie ein Diktat, das zwischen Prozessen geteilt werden soll
for address in domain_list:
p1 = mp.Process(target=ping, args=(address, result,))
proc.append(p1)
for p1 in proc:
p1.start()
for p1 in proc:
p1.join()
#Kopieren Sie das Ping-Ergebnis vom Ergebnis des Diktattyps in das Protokoll des DataFrame.
for address in domain_list:
log.ix[current_position, address] = result[address]
#Da das Protokoll weiterhin durch Drehen verwendet wird, die aktuelle Position, die die neuesten Daten enthält
#Je nach Wert Datenrahmen.sum()Der zu aggregierende Bereich wird in geändert.
value = log.ix[current_position-evaluate_range:current_position, :].sum() if current_position >= evaluate_range else \
log.ix[0:current_position, :].sum() + log.ix[bottom-(evaluate_range-current_position):bottom,:].sum()
#Ähnlich wie beim obigen Wert sollten Sie mit einem etwas kürzeren Prüfbereich wiederherstellen, um die Beurteilung zum Zeitpunkt des Ping-OK so schnell wie möglich wiederzugeben._Wert berechnen
recover_value = log.ix[current_position-recover_range:current_position, :].sum() if current_position >= recover_range else \
log.ix[0:current_position, :].sum() + log.ix[bottom-(recover_range-current_position):bottom,:].sum()
result = value[(value > evaluate_range*evaluate_ratio) & (recover_value != 0)]
#Ich versuche, sendGmail nur aufzurufen, wenn sich das Ergebnis ändert, damit die Benachrichtigungsmail nicht zu viel fliegt.
#Da das Design nicht die Details der Anzahl der Ping-NGs berücksichtigt, wird nur der Index extrahiert und verglichen.
#.difference()Überprüft das Differential nicht in beide Richtungen, daher verbinde ich die Einwegprüfung mit oder.
if not pd.Series().index.equals(result.index.difference(before_result.index)) or not pd.Series().index.equals(before_result.index.difference(result.index)):
if result.size != 0:
sendGmail(result.index.str.cat(sep='\n'))
before_result = result
else:
sendGmail('All server are normally operating.')
before_result = result
current_position += 1
if current_position > bottom:
current_position = 0
time.sleep(1)
Ich benutze Pandas, weil ich die bekannten Pandas für die Protokollaggregation mag. Für die Mehrfachverarbeitung benötigten wir einige gemeinsam nutzbare Daten, daher haben wir result = manager.dict () an die Ping-Funktion übergeben.
Recommended Posts