def analizarHDD(host):
while True:
# calculos de tiempos basado en la ultima entrada de la base
tiempo_final = int(rrdtool.last(host + ".rrd"))
tiempo_inicial = tiempo_final - 3600
ret = rrdtool.graphv(
host + "HDD.png", "--start", str(tiempo_inicial), "--end",
str(tiempo_final), "--title", "Carga del disco duro",
"--vertical-label=Uso de HDD (%)", '--lower-limit', '0',
'--upper-limit', '100', "DEF:carga=" + host + ".rrd:HDD:AVERAGE",
"CDEF:umbral45=carga,45,LT,0,carga,IF",
"CDEF:umbral50=carga,50,LT,0,carga,IF",
"CDEF:umbral60=carga,60,LT,0,carga,IF",
"VDEF:cargaMAX=carga,MAXIMUM", "VDEF:cargaMIN=carga,MINIMUM",
"VDEF:cargaSTDEV=carga,STDEV", "VDEF:cargaLAST=carga,LAST",
"AREA:carga#00FF00:Carga del HDD",
"AREA:umbral45#1ECC0E:Tráfico de carga mayor que 45",
"AREA:umbral50#C97D02:Tráfico de carga mayor que 50",
"AREA:umbral60#FF0000:Tráfico de carga mayor que 60",
"HRULE:45#1ECC0E:Umbral 1 - 45%",
"HRULE:50#C97D02:Umbral 45 - 50%",
"HRULE:60#FF0000:Umbral 60 - 100%", "PRINT:cargaMAX:%6.2lf %S",
"GPRINT:cargaMIN:%6.2lf %SMIN", "GPRINT:cargaSTDEV:%6.2lf %SSTDEV",
"GPRINT:cargaLAST:%6.2lf %SLAST")
# print (ret)
# print(ret.keys())
# print(ret.items())
ultimo_valor = float(ret['print[0]'])
#print("Ultimo valor HDD: "+ str(ultimo_valor))
if ultimo_valor >= 45 and ultimo_valor < 50:
#send_alert_attached("Sobrepasa 45% del HDD", host, "HDD")
print("Sobrepasa 45% del HDD")
sleep(60)
elif ultimo_valor >= 50 and ultimo_valor < 60:
#send_alert_attached("Sobrepasa 50% del HDD, cuidado", host, "HDD")
print("Sobrepasa 50% del HDD, cuidado")
sleep(60)
elif ultimo_valor >= 60 and ultimo_valor <= 100:
send_alert_attached("Sobrepasa 60% del HDD, niveles criticos",
host, "HDD")
print("Sobrepasa 60% del HDD, niveles criticos")
sleep(60)
sleep(5)
def grafica(base):
nombreBase = base + ".rrd"
nombreResultado = base + ".png"
ultima_lectura = int(rrdtool.last(nombreBase))
tiempo_final = ultima_lectura
tiempo_inicial = tiempo_final - 1800
while 1:
ret = rrdtool.graphv(
nombreResultado, "--start", str(tiempo_inicial),
"--vertical-label=Uso HDD", "--title=Uso de HDD", "--color",
"ARROW#009900", '--vertical-label', "Uso de HDD (M)",
'--lower-limit', '0', '--upper-limit', '100',
"DEF:carga=" + nombreBase + ":CPUload:AVERAGE",
"DEF:carga2=" + nombreBase + ":CPUload:AVERAGE", "LINE1:50",
"AREA:5#ff000022:stack", "VDEF:CPUlast=carga,LAST",
"VDEF:CPUmin=carga,MINIMUM", "VDEF:CPUavg=carga,AVERAGE",
"VDEF:CPUmax=carga,MAXIMUM",
"COMMENT: Now Min Avg Max//n",
"GPRINT:CPUlast:%12.0lf%s", "GPRINT:CPUmin:%10.0lf%s",
"GPRINT:CPUavg:%13.0lf%s", "GPRINT:CPUmax:%13.0lf%s",
"VDEF:a=carga,LSLSLOPE", "VDEF:b=carga,LSLINT",
'CDEF:avg2=carga,POP,a,COUNT,*,b,+',
'CDEF:avg3=carga2,POP,a,COUNT,*,b,+', "LINE3:3000000#000000",
"LINE3:6000000#00BB00", "LINE3:10000000#BB0000",
"LINE2:avg2#FFBB00", "AREA:carga#00FF00:CPU load",
"PRINT:carga:LAST:%6.1lf")
print(ret['print[0]'])
a = float(ret['print[0]'])
if (a > float(10000000)):
send_alert_attached("Alerta de Sobre Carga de HDD")
# else:
# send_alert_attached("Vas bien papu")
time.sleep(15)
def analizarRAM(host):
while True:
# calculos de tiempos basado en la ultima entrada de la base
tiempo_final = int(rrdtool.last(host + ".rrd"))
tiempo_inicial = tiempo_final - 3600
ret = rrdtool.graphv(
host + "RAM.png", "--start", str(tiempo_inicial), "--end",
str(tiempo_final), "--title", "Carga de Memoria RAM",
"--vertical-label=Uso de RAM (%)", '--lower-limit', '0',
'--upper-limit', '100', "DEF:carga=" + host + ".rrd:RAM:AVERAGE",
"CDEF:umbral60=carga,60,LT,0,carga,IF",
"CDEF:umbral75=carga,75,LT,0,carga,IF",
"CDEF:umbral85=carga,85,LT,0,carga,IF",
"VDEF:cargaMAX=carga,MAXIMUM", "VDEF:cargaMIN=carga,MINIMUM",
"VDEF:cargaSTDEV=carga,STDEV", "VDEF:cargaLAST=carga,LAST",
"AREA:carga#00FF00:Carga de la RAM",
"AREA:umbral60#1ECC0E:Tráfico de carga mayor que 60",
"AREA:umbral75#C97D02:Tráfico de carga mayor que 75",
"AREA:umbral85#FF0000:Tráfico de carga mayor que 85",
"HRULE:60#1ECC0E:Umbral 1 - 75%",
"HRULE:75#C97D02:Umbral 75 - 85%",
"HRULE:85#FF0000:Umbral 85 - 100%", "PRINT:cargaMAX:%6.2lf %S",
"GPRINT:cargaMIN:%6.2lf %SMIN", "GPRINT:cargaSTDEV:%6.2lf %SSTDEV",
"GPRINT:cargaLAST:%6.2lf %SLAST")
# print (ret)
# print(ret.keys())
# print(ret.items())
ultimo_valor = float(ret['print[0]'])
print("Ultimo valor RAM: " + str(ultimo_valor))
if ultimo_valor >= 60 and ultimo_valor < 75:
send_alert_attached("Sobrepasa 60% de la RAM", host, "RAM")
print("Sobrepasa 60% de la RAM")
sleep(60)
elif ultimo_valor >= 75 and ultimo_valor < 85:
send_alert_attached("Sobrepasa 75% de la RAM", host, "RAM")
print("Sobrepasa 75% de la RAM, cuidado")
sleep(60)
elif ultimo_valor >= 90 and ultimo_valor <= 100:
send_alert_attached("Sobrepasa 90% de la RAM, niveles criticos",
host, "RAM")
print("Sobrepasa 90% de la RAM, niveles criticos")
sleep(60)
sleep(5)
def DetectarComportamiento(ip, comunidad, idAgente):
global banderaCorreos
banderaMC = True
banderaPre = True
thread_read = threading.Thread(target=EnviarCorreo, args=[ip, idAgente])
thread_read.start()
while (ip in agentes):
CPULoad = consultaSNMP(comunidad, ip, '1.3.6.1.2.1.25.3.3.1.2.196608')
#CPULoad = consultaSNMP(comunidad, ip, '1.3.6.1.2.1.2.2.1.10.1' )
valor = "N:" + CPULoad
rrdtool.update("RRDsAgentes/prediccion" + idAgente + '.rrd', valor)
rrdtool.dump('RRDsAgentes/prediccion' + idAgente + '.rrd',
'RRDsAgentes/prediccion' + idAgente + '.xml')
time.sleep(0.5)
umbral = 90
ultimo = rrdtool.last("RRDsAgentes/prediccion" + idAgente + ".rrd")
tiempo_inicial = ultimo - 200
ret2 = rrdtool.graphv(
"Graficas/minimoscuadrados" + idAgente + ".png", "--start",
str(tiempo_inicial), "--end", str(ultimo + 60 * 2), "--title",
"Carga de CPU", "--vertical-label=Carga de CPU", '--lower-limit',
'0', '--upper-limit', '100', "DEF:carga=" +
"RRDsAgentes/prediccion" + idAgente + '.rrd' + ":carga:AVERAGE",
"CDEF:umbral25=carga," + str(umbral) + ",LT,0,carga,IF",
"VDEF:cargaMAX=carga,MAXIMUM", "VDEF:cargaMIN=carga,MINIMUM",
"VDEF:cargaSTDEV=carga,STDEV", "VDEF:cargaLAST=carga,LAST",
"VDEF:m=carga,LSLSLOPE", "VDEF:b=carga,LSLINT",
'CDEF:y=carga,POP,m,COUNT,*,b,+', "VDEF:yUltimo=y,LAST",
"AREA:umbral25#FF9F00:Prediccion en 2 min ",
"GPRINT:yUltimo:%6.2lf %S.", "HRULE:" + str(umbral) +
"#FF0000:Umbral al " + str(umbral) + "%\\n",
"AREA:carga#00FF00:Carga del CPU", "GPRINT:cargaMIN:%6.2lf %SMIN",
"GPRINT:cargaSTDEV:%6.2lf %SSTDEV",
"GPRINT:cargaLAST:%6.2lf %SLAST", "LINE2:y#FFBB00",
"PRINT:yUltimo:%6.2lf %S ")
#print(str(ret2['print[0]']))
try:
prediccion = float(ret2['print[0]'])
except:
prediccion = 0.0
if (prediccion >= 90.0 and banderaCorreos and banderaMC):
print("Enviando correo prediccion")
banderaMC = False
send_alert_attached(
"El agente cerca de alcanzar el umbral establecido",
"Graficas/minimoscuadrados" + idAgente,
"El porcentaje de uso de cpu del agente " + ip +
" se encuentra cerca del 90%. Por favor, tomar las medidas correspondientes."
)
ret = rrdtool.graphv(
"Graficas/prediccion" + idAgente + ".png",
'--start',
str(ultimo - 60 * 5),
'--end',
str(ultimo + 120),
'--title=' + "Comportamiento anómalo",
"--vertical-label=Carga de cpu",
'--slope-mode',
"DEF:valor=" + "RRDsAgentes/prediccion" + idAgente + ".rrd" +
":carga:AVERAGE",
"DEF:prediccion=" + "RRDsAgentes/prediccion" + idAgente + ".rrd" +
":carga:HWPREDICT",
"DEF:desv=" + "RRDsAgentes/prediccion" + idAgente + ".rrd" +
":carga:DEVPREDICT",
"DEF:falla=" + "RRDsAgentes/prediccion" + idAgente + ".rrd" +
":carga:FAILURES",
"CDEF:carga=valor",
"CDEF:limiteSuperior=prediccion,desv,2,*,+",
"CDEF:limiteInferior=prediccion,desv,2,*,-",
"CDEF:superior=limiteSuperior",
"CDEF:inferior=limiteInferior",
"CDEF:pred=prediccion,",
"TICK:falla#FDD017:1.0:_Fallas\\n",
"LINE3:carga#00FF00:Carga cpu",
"VDEF:cargaMAX=carga,MAXIMUM",
"VDEF:cargaMIN=carga,MINIMUM",
"VDEF:cargaLAST=carga,LAST",
"GPRINT:cargaMIN:%6.2lf %SCarga",
"GPRINT:cargaMIN:%6.2lf %SMin",
"GPRINT:cargaMAX:%6.2lf %sMax",
"LINE1:pred#FF00FF:Predicción",
"VDEF:predLast=pred,LAST",
"GPRINT:predLast:%6.2lf %spred",
"LINE1:superior#ff0000:Limite superior",
"LINE1:inferior#0000FF:Limite inferior",
"VDEF:lastfail=falla,LAST",
"PRINT:lastfail: %c :strftime",
"PRINT:lastfail:%6.2lf %S ",
'PRINT:falla:MIN:%1.0lf',
'PRINT:falla:MAX:%1.0lf',
)
ultima_falla = ret['print[1]']
try:
val = float(ultima_falla)
except:
val = 0.0
if (banderaCorreos and banderaPre):
if (val > 0):
banderaPre = False
print("Enviando correo fallas")
send_alert_attached(
"Un agente ha presentado una falla",
"Graficas/prediccion" + idAgente,
"El porcentaje de uso de cpu del agente " + ip +
" ha presentado una falla . Por favor, tomar las medidas correspondientes."
)
def analizarCPU(host):
while True:
# calculos de tiempos basado en la ultima entrada de la base
tiempo_final = int(rrdtool.last(host + ".rrd"))
tiempo_inicial = tiempo_final - 3600
ret = rrdtool.graphv(
host + "CPU.png",
"--start",
str(tiempo_inicial),
"--end",
str(tiempo_final),
"--title",
"Carga del microprocesador",
"--vertical-label=Uso de CPU (%)",
'--lower-limit',
'0',
'--upper-limit',
'100',
"DEF:carga=" + host + ".rrd:CPU:AVERAGE",
"CDEF:umbral70=carga,70,LT,0,carga,IF",
"CDEF:umbral80=carga,80,LT,0,carga,IF",
"CDEF:umbral90=carga,90,LT,0,carga,IF",
"VDEF:cargaMAX=carga,MAXIMUM",
"VDEF:cargaMIN=carga,MINIMUM",
"VDEF:cargaSTDEV=carga,STDEV",
"VDEF:cargaLAST=carga,LAST",
"AREA:carga#00FF00:Carga del CPU",
"AREA:umbral70#1ECC0E:Tráfico de carga mayor que 70",
"AREA:umbral80#C97D02:Tráfico de carga mayor que 80",
"AREA:umbral90#FF0000:Tráfico de carga mayor que 90",
"HRULE:45#1ECC0E:Umbral 1 - 80%",
"HRULE:50#C97D02:Umbral 80 - 90%",
"HRULE:60#FF0000:Umbral 90 - 100%",
"PRINT:cargaMAX:%6.2lf %S",
"GPRINT:cargaMIN:%6.2lf %SMIN",
"GPRINT:cargaSTDEV:%6.2lf %SSTDEV",
"GPRINT:cargaLAST:%6.2lf %SLAST",
#Y = MX + B
"VDEF:m=carga,LSLSLOPE",
"VDEF:b=carga,LSLINT",
"CDEF:Y=carga,POP,m,COUNT,*,b,+",
"LINE2:Y#FF0000")
# print (ret)
# print(ret.keys())
# print(ret.items())
ultimo_valor = float(ret['print[0]'])
#print("Ultimo valor CPU: "+ str(ultimo_valor))
if ultimo_valor >= 70 and ultimo_valor < 80:
#send_alert_attached("Sobrepasa 45% del CPU", host, "CPU")
print("Sobrepasa 45% del CPU")
sleep(60)
elif ultimo_valor >= 80 and ultimo_valor < 90:
#send_alert_attached("Sobrepasa 50% del CPU, cuidado", host, "CPU")
print("Sobrepasa 50% del CPU, cuidado")
sleep(60)
elif ultimo_valor >= 90 and ultimo_valor <= 100:
send_alert_attached("Sobrepasa 60% del CPU, niveles criticos",
host, "CPU")
print("Sobrepasa 60% del CPU, niveles criticos")
sleep(60)
sleep(5)
def actualizarDatosGrafica():
session = Session(hostname='localhost',
community='comunidadASR',
version=2)
enviadoReadyCPU = True
enviadoSetCPU = True
enviadoGoCPU = True
enviadoReadyRAM = True
enviadoSetRAM = True
enviadoGoRAM = True
while 1:
#Para las graficas normales
total_input_traffic = int(obtenerValor(monitoreosSNMP[0][1]))
total_output_traffic = int(obtenerValor(monitoreosSNMP[0][2]))
total_input_SegTCP = int(obtenerValor(monitoreosSNMP[1][1]))
total_output_SegTCP = int(obtenerValor(monitoreosSNMP[1][2]))
total_input_DatUDP = int(obtenerValor(monitoreosSNMP[2][1]))
total_output_DatUDP = int(obtenerValor(monitoreosSNMP[2][2]))
total_input_PaqSNMP = int(obtenerValor(monitoreosSNMP[3][1]))
total_output_PaqSNMP = int(obtenerValor(monitoreosSNMP[3][2]))
total_input_ICP = int(obtenerValor(monitoreosSNMP[4][1]))
total_output_ICP = int(obtenerValor(monitoreosSNMP[4][2]))
valor1 = "N:" + str(total_input_traffic) + ':' + str(
total_output_traffic)
valor2 = "N:" + str(total_input_SegTCP) + ':' + str(
total_output_SegTCP)
valor3 = "N:" + str(total_input_DatUDP) + ':' + str(
total_output_DatUDP)
valor4 = "N:" + str(total_input_PaqSNMP) + ':' + str(
total_output_PaqSNMP)
valor5 = "N:" + str(total_input_ICP) + ':' + str(total_output_ICP)
rrdtool.update('bdrrdtool/g1.rrd', valor1)
rrdtool.dump('bdrrdtool/g1.rrd', 'bdrrdtool/g1.xml')
rrdtool.update('bdrrdtool/g2.rrd', valor2)
rrdtool.dump('bdrrdtool/g2.rrd', 'bdrrdtool/g2.xml')
rrdtool.update('bdrrdtool/g3.rrd', valor3)
rrdtool.dump('bdrrdtool/g3.rrd', 'bdrrdtool/g3.xml')
rrdtool.update('bdrrdtool/g4.rrd', valor4)
rrdtool.dump('bdrrdtool/g4.rrd', 'bdrrdtool/g4.xml')
rrdtool.update('bdrrdtool/g5.rrd', valor5)
rrdtool.dump('bdrrdtool/g5.rrd', 'bdrrdtool/g5.xml')
# Empieza linea base
uso_CPU1 = int(obtenerValor(cpuSNMP[0]))
valor1 = "N:" + str(uso_CPU1)
rrdtool.update("bdrrdtool/gCPU1.rrd", valor1)
uso_CPU2 = int(obtenerValor(cpuSNMP[1]))
valor2 = "N:" + str(uso_CPU1)
rrdtool.update("bdrrdtool/gCPU2.rrd", valor2)
uso_CPU3 = int(obtenerValor(cpuSNMP[2]))
valor3 = "N:" + str(uso_CPU1)
rrdtool.update("bdrrdtool/gCPU3.rrd", valor3)
uso_CPU4 = int(obtenerValor(cpuSNMP[3]))
valor4 = "N:" + str(uso_CPU1)
rrdtool.update("bdrrdtool/gCPU4.rrd", valor4)
ramusada = int(obtenerValor(rendimientoSNMP[1]))
ramtotal = int(obtenerValor(rendimientoSNMP[2]))
porcentaje = int((ramusada * 100) / ramtotal)
valor2 = "N:" + str(porcentaje)
rrdtool.update("bdrrdtool/gRAM.rrd", valor2)
cpu_utilizado = 0
if (uso_CPU1 > 40):
cpu_utilizado = 1
elif (uso_CPU2 > 40):
cpu_utilizado = 2
elif (uso_CPU3 > 40):
cpu_utilizado = 3
elif (uso_CPU4 > 40):
cpu_utilizado = 4
if (uso_CPU1 > 40 or uso_CPU2 > 40 or uso_CPU3 > 40
or uso_CPU4 > 40 and enviadoReadyCPU):
send_alert_attached("Sobrepasa Umbral ready del uso del CPU",
"CPU", cpu_utilizado)
enviadoReadyCPU = False
elif (uso_CPU1 > 50 or uso_CPU2 > 50 or uso_CPU3 > 50
or uso_CPU4 > 50 and enviadoSetCPU):
send_alert_attached("Sobrepasa Umbral set del uso del CPU", "CPU",
cpu_utilizado)
enviadoSetCPU = False
elif (uso_CPU1 > 60 or uso_CPU2 > 60 or uso_CPU3 > 60
or uso_CPU4 > 60 and enviadoGoCPU):
send_alert_attached("Sobrepasa Umbral go del uso del CPU", "CPU",
cpu_utilizado)
enviadoGoCPU = False
if (porcentaje > 45 and porcentaje < 50 and enviadoReadyRAM):
send_alert_attached("Sobrepasa Umbral ready del uso de la RAM",
"RAM", cpu_utilizado)
enviadoReadyRAM = False
elif (porcentaje > 50 and porcentaje < 60 and enviadoSetRAM):
enviadoSetRAM = False
send_alert_attached("Sobrepasa Umbral set del uso de la RAM",
"RAM", cpu_utilizado)
elif (porcentaje > 60 and enviadoGoRAM):
enviadoGoRAM = False
send_alert_attached("Sobrepasa Umbral go del uso de la RAM", "RAM",
cpu_utilizado)
time.sleep(1)
def crearGrafica(numero, id):
#print(str(numero))
archivoRrd = 'trend' + str(numero) + '-' + str(id) + '.rrd'
archivoPng = 'trend' + str(numero) + '-' + str(id) + '.png'
ultima_lectura = int(rrdtool.last(archivoRrd))
timepo_final = ultima_lectura
tiempo_inicial = timepo_final - 3600
#variable de tiempo para no enviar demasiados correos
send = 0
while 1:
ret = rrdtool.graphv(
archivoPng,
"--start",
str(tiempo_inicial), #Modifcar para tiempo incial
#"--end",str(tiempo_final),
#"--vertical-label=Carga CPU",
"--title=Uso de CPU",
"--color",
"ARROW#009900",
'--vertical-label',
"Uso de CPU (%)",
'--lower-limit',
'0',
'--upper-limit',
'100',
"DEF:carga=" + archivoRrd + ":CPUload:AVERAGE",
"CDEF:carga60=carga,60,GT,0,carga,IF",
#"LINE1:30",
#"AREA:5#ff000022:stack",
#"VDEF:CPUlast=carga,LAST",
"VDEF:CPUmin=carga,MINIMUM",
"VDEF:CPUavg=carga,AVERAGE",
"VDEF:cargaSTDEV=carga,STDEV",
"VDEF:cargaLAST=carga,LAST",
"VDEF:CPUmax=carga,MAXIMUM",
"AREA:carga#00FF00:CPU Carga Elevada",
"AREA:carga60#FF9F00:Carga menor al 60%",
"HRULE:60#FF0000:Alerta Sobrecarga",
"HRULE:50#00FF00:Uso Medio",
"HRULE:45#0000FF:Uso Moderado",
"COMMENT: Now Min Avg Max//n",
#"GPRINT:CPUlast:%12.0lf%s",
#"GPRINT:CPUmin:%10.0lf%s",
#"GPRINT:CPUavg:%13.0lf%s",
#"GPRINT:CPUmax:%13.0lf%s"
"GPRINT:CPUmax:%6.2lf %SMAX",
"GPRINT:CPUmin:%6.2lf %SMIN",
"GPRINT:cargaSTDEV:%6.2lf %SSTDEV",
"PRINT:cargaLAST:%6.2lf%S"
#"VDEF:a=carga,LSLSLOPE",
#"VDEF:b=carga,LSLINT",
#'CDEF:avg2=carga,POP,a,COUNT,*,b,+',
#"LINE2:avg2#FFBB00" )
)
#print (ret)
#print(ret.keys())
#print(ret.items())
ultimo_valor = float(ret['print[0]'])
#print ("ultimo_valor = " + str(ultimo_valor))
if ultimo_valor > 60 and send == 0:
send_alert_attached("Carga alta de nucleo: " + id, archivoPng)
#else:
# send = 0
send += 15
if (send > 300):
send = 0
"""for x in range(0,7):
res= 'legend['+str(x)+']'
print(ret[res])"""
time.sleep(15)