def test_callback_args(self):
"""
Test whether all required arguments are passed in kwargs.
"""
if self.check_skip():
return
def my_callback(*args, **kwargs):
required_args = ('filename', 'cf', 'start', 'end', 'step')
for k in required_args:
self.assertIn(k, kwargs)
items = int((kwargs['end'] - kwargs['start']) / kwargs['step'])
return {
'start': kwargs['start'],
'step': 300,
'data': {
'a': [math.sin(x / 200) for x in range(0, items)],
'b': [math.cos(x / 200) for x in range(10, items)],
'c': [math.sin(x / 100) for x in range(100, items)],
}
}
rrdtool.register_fetch_cb(my_callback)
rrdtool.graphv(*self.graphv_args)
class CreateRRD:
ret = rrdtool.create("trend.rrd", "--start", 'N', "--step", '10',
"DS:CPUload:GAUGE:600:U:U", "RRA:AVERAGE:0.5:1:24")
if ret:
print(rrdtool.error())
ultima_lectura = int(rrdtool.last("trend.rrd"))
tiempo_final = ultima_lectura
tiempo_inicial = tiempo_final - 360
ret = rrdtool.graphv(
"trend.png", "--start", str(tiempo_inicial), "--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=trend.rrd:CPUload:AVERAGE", "AREA:carga#00FF00:Carga CPU",
"LINE1:30", "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",
"GPRINT:CPUlast:%12.0lf%s", "GPRINT:CPUmin:%10.0lf%s",
"GPRINT:CPUavg:%13.0lf%s", "GPRINT:CPUmax:%13.0lf%s",
"VDEF:m=carga,LSLSLOPE", "VDEF:b=carga,LSLINT",
'CDEF:tendencia=carga,POP,m,COUNT,*,b,+', "LINE2:tendencia#FFBB00")
print(ret)
print(ret.keys())
print(ret.items())
def rrd_graph(path, rrd_opts, graph_opts):
''' create a graph for rrd
if path is "-", image is returned as part of dictionary.
Keys in dictionary:
graph_end
graph_height
graph_left
graph_start
graph_top
graph_width
image
image_height
image_width
value_max
value_min
'''
data = dict()
if path != "-" and not os.path.exists(os.path.dirname(path)):
os.makedirs(os.path.dirname(path))
try:
logging.info("creating graph %s", path)
data = rrdtool.graphv(path, rrd_opts, graph_opts)
except (rrdtool.OperationalError, rrdtool.ProgrammingError) as e:
logging.error("failed to create graph %s: %s", path, str(e))
return data
def generate_graph(self, interval=None, **kwargs):
assert self.objects, "Cannot render graph without any objects"
# Make sure that all collected data is in the database
# to get a recent graph image
for object in self.objects:
object.commit()
args = self._make_command_line(interval, **kwargs)
self.log.info(_("Generating graph %s") % self)
rrd_graph = self.rrd_graph
# Add DEFs for all objects
if not any((e.startswith("DEF:") for e in rrd_graph)):
args += self._add_defs()
args += rrd_graph
args = self._add_vdefs(args)
# Convert arguments to string
args = [str(e) for e in args]
for arg in args:
self.log.debug(" %s" % arg)
graph = rrdtool.graphv("-", *args)
return {
"image": graph.get("image"),
"image_height": graph.get("image_height"),
"image_width": graph.get("image_width"),
}
def generate_graph(self, interval=None, **kwargs):
assert self.objects, "Cannot render graph without any objects"
# Make sure that all collected data is in the database
# to get a recent graph image
for object in self.objects:
object.commit()
args = self._make_command_line(interval, **kwargs)
self.log.info(_("Generating graph %s") % self)
rrd_graph = self.rrd_graph
# Add DEFs for all objects
if not any((e.startswith("DEF:") for e in rrd_graph)):
args += self._add_defs()
args += rrd_graph
args = self._add_vdefs(args)
# Convert arguments to string
args = [str(e) for e in args]
for arg in args:
self.log.debug(" %s" % arg)
with Environment(self.timezone, self.locale.lang):
graph = rrdtool.graphv("-", *args)
return {
"image" : graph.get("image"),
"image_height" : graph.get("image_height"),
"image_width" : graph.get("image_width"),
}
def camera_image(self):
"""
Return a still image response from the camera.
This will run rrdtool graph to generate a temporary file which will be served by this method.
"""
_LOGGER.debug("Get RRD camera image")
try:
ret = rrdtool.graphv(
"-",
"--width",
str(self._config[CONF_WIDTH]),
"--height",
str(self._config[CONF_HEIGHT]),
"--start",
"-" + self._config[CONF_TIMERANGE],
*self._config[CONF_RRDGRAPH_OPTIONS],
*self._defs,
*self._lines,
*self._config[CONF_ARGS],
)
return ret["image"]
except rrdtool.OperationalError as exc:
_LOGGER.error(exc)
return False
def GraficarUmbrales(idAgente, ip, entidad, UMBRAL_READY, UMBRAL_SET,
UMBRAL_GO, labelCarga):
ultima_lectura = int(
rrdtool.last("RRDsAgentes/monitoreo" + idAgente + ".rrd"))
tiempo_final = ultima_lectura
tiempo_inicial = tiempo_final - 120
nombreGrafica = ip.replace(".", "") + entidad
ret = rrdtool.graphv(
"Monitoreo/" + nombreGrafica + ".png", "--start", str(tiempo_inicial),
"--vertical-label=Carga del CPU: " + nombreGrafica, '--lower-limit',
'0', '--upper-limit', '100', "DEF:cargaEntidad=RRDsAgentes/monitoreo" +
idAgente + ".rrd:" + entidad + ":AVERAGE",
"CDEF:carga=cargaEntidad," + UMBRAL_READY + ",LT,cargaEntidad,0,IF",
"CDEF:umbralReady=cargaEntidad," + UMBRAL_READY +
",GT,cargaEntidad,0,IF", "CDEF:umbralSet=cargaEntidad," + UMBRAL_SET +
",GT,cargaEntidad,0,IF", "CDEF:umbralGo=cargaEntidad," + UMBRAL_GO +
",GT,cargaEntidad,0,IF", "VDEF:cargaMAX=cargaEntidad,MAXIMUM",
"VDEF:cargaMIN=cargaEntidad,MINIMUM",
"VDEF:cargaLAST=cargaEntidad,LAST",
"AREA:carga#988D8D:" + labelCarga + " menor que " + UMBRAL_READY,
"AREA:umbralReady#50DA23:" + labelCarga + " mayor que " + UMBRAL_READY,
"AREA:umbralSet#FF8B00:" + labelCarga + " mayor que " + UMBRAL_SET,
"AREA:umbralGo#FF0000:" + labelCarga + " que " + UMBRAL_GO, "HRULE:" +
UMBRAL_READY + "#50DA23:Umbral ready 1 - " + UMBRAL_READY + "%",
"HRULE:" + UMBRAL_SET + "#FF8B00:Umbral set " + UMBRAL_SET + " - " +
UMBRAL_GO + "%",
"HRULE:" + UMBRAL_GO + "#FF0000:Umbral go " + UMBRAL_GO + " - 100%",
"PRINT:cargaLAST:%6.2lf %S", "GPRINT:cargaMAX:%6.2lf %SMAX",
"GPRINT:cargaMIN:%6.2lf %SMIN", "GPRINT:cargaLAST:%6.2lf %SLAST")
VerificarUmbrales(UMBRAL_READY, UMBRAL_SET, UMBRAL_GO, ret['print[0]'],
entidad, nombreGrafica)
class Notification1:
#def run(self):
ret = rrdtool.graphv("deteccion.png",
"--start", str(tiempo_inicial),
"--end", str(tiempo_final),
"--title", "Carga de CPU",
"--vertical-label=Uso de CPU (%)",
'--lower-limit', '0',
'--upper-limit', '100',
"DEF:carga=trend.rrd:CPUload:AVERAGE",
"CDEF:umbral80=carga,80,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:umbral80#FF9F00:Tráfico de carga mayor que 80",
"AREA:umbral80#FF9F00:Tráfico de carga mayor que 25",
"HRULE:80#FF0000:Umbral 1 - 80%",
"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]'])
if ultimo_valor > 23:
print("Sobrepasa Umbral línea base")
def graficarRAM(agente: Agente):
"""Gráfica una BD de RRDTOOL
Usa la calse de Email para enviar un correo
en caso de pasar un umbral"""
global ENVIO
UMBRAL_RAM = 90
UMBRAL_RAMMED = 80
UMBRAL_RAMBAJ = 70
ultima_lectura = int(rrdtool.last(RUTARRD+agente.ip+"RAM.rrd"))
tiempo_final = ultima_lectura
tiempo_inicial = tiempo_final - 600
try:
ret = rrdtool.graphv( RUTAGRA+"RAM.png",
"--start",str(tiempo_inicial),
"--end",str(tiempo_final),
"--vertical-label=RAM load",
'--lower-limit', '0',
'--upper-limit', '100',
"DEF:carga="+RUTARRD+agente.ip+"RAM.rrd:RAMload:AVERAGE",
"CDEF:umbral1=carga,"+str(UMBRAL_RAM)+",LT,0,carga,IF",
"CDEF:umbral=carga,"+str(UMBRAL_RAMMED)+",LT,0,carga,IF",
"CDEF:umbral0=carga,"+str(UMBRAL_RAMBAJ)+",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:umbral#FF9F00:Carga RAM mayor que "+str(UMBRAL_RAM),
"AREA:umbral0#0000FF:Carga RAM mayor que "+str(UMBRAL_RAMBAJ),
"AREA:umbral#FF9F00:Carga RAM mayor que "+str(UMBRAL_RAMMED),
"AREA:umbral1#FF0000:Carga RAM mayor que "+str(UMBRAL_RAM),
"HRULE:"+str(UMBRAL_RAMMED)+"#0000FF:Umbral - medio "+str(UMBRAL_RAMMED),
"HRULE:"+str(UMBRAL_RAM)+"#FF0000:Umbral - Oh, no "+str(UMBRAL_RAM),
"PRINT:cargaLAST:%6.2lf",
"GPRINT:cargaMIN:%6.2lf %SMIN",
#"GPRINT:cargaSTDEV:%6.2lf %SSTDEV",
"GPRINT:cargaLAST:%6.2lf %SLAST" )
#Obtener el último valor de la gráfica.
ultimo_valor=float(ret['print[0]'])
#print('Último valor '+ str(ultimo_valor))
if (ultimo_valor>UMBRAL_RAMBAJ and ENVIO1[0]):
print('La RAM del agente '+agente.ip+' se está quemando, corre!!! D=')
ENVIO1[0] = False
#send_alert_attached("Sobrepasa Umbral Bajo RAM", "RAM.png")
if (ultimo_valor>UMBRAL_RAMMED and ENVIO1[1]):
print('La RAM del agente '+agente.ip+' se está quemando, corre!!! D=')
ENVIO1[1] = False
#send_alert_attached("Sobrepasa Umbral Medio de RAM", "RAM.png")
if (ultimo_valor>UMBRAL_RAM and ENVIO1[2]):
print('La RAM del agente '+agente.ip+' se está quemando, corre!!! D=')
ENVIO1[2] = False
#send_alert_attached("Sobrepasa Umbral Alto de RAM", "RAM.png")
except Exception as e:
print('Error al momento de graficar RAM: '+ str(e))
def graph(request):
project_dir = "/home/pi/virtualenvs/BrewPi"
displayhours = 2
args = ""
width = 600
height = 400
if request.method == 'GET':
try:
displayhours = int(request.GET['hours'])
except:
pass
try:
width = int(request.GET['width'])
except:
pass
try:
height = int(request.GET['height'])
except:
pass
arg = ["", ""]
#
file = rrdtool.graphv(
"-", "--start", "-" + str(displayhours) + "h",
"--vertical-label=Temperature (C)", "-w" + str(width),
"-h" + str(height), "-D", "-Y",
"DEF:HLT_Temp=" + project_dir + "/rrd/temps.rrd:temp_HLT:AVERAGE",
"LINE1:HLT_Temp#00FF00:HLT Temperature",
"CDEF:unavailable=HLT_Temp,UN,INF,0,IF", "AREA:unavailable#d0d0d0")
return HttpResponse(file['image'], mimetype="image/png")
def camera_image(self):
"""
Return a still image response from the camera.
This will run rrdtool graph to generate a temporary file which will be served by this method.
"""
_LOGGER.debug("Get RRD camera image")
try:
ret = rrdtool.graphv(
"-",
"--width",
str(self._width),
"--height",
str(self._height),
"--start",
"-" + self._timerange,
*self._defs,
*self._lines,
*self._args,
)
return ret["image"]
except rrdtool.OperationalError as exc:
_LOGGER.error(exc)
return False
def makeCPUGraph(root, startTime, endTime = rrdConstants.NOW):
baseline = rrdConstants.BASELINE[rrdConstants.DS_CPU]
return rrdtool.graphv(root + '/' + rrdConstants.CPU_GRAPH,
'--start', startTime,
'--end', endTime,
'--width', rrdConstants.GRAPH_WIDTH,
'--height', rrdConstants.GRAPH_HEIGHT,
'--full-size-mode',
'--title', 'Porcentage de uso de procesador.',
'--vertical-label', '% CPU',
'--lower-limit', '0',
'--upper-limit', '100',
'DEF:data=' + root + '/' + appConstants.DB_FILENAME + ':' + rrdConstants.DS_CPU + ':AVERAGE',
'CDEF:ready=data,' + str(baseline[rrdConstants.READY]) + ',GT,data,0,IF',
'CDEF:set=data,' + str(baseline[rrdConstants.SET]) + ',GT,data,0,IF',
'CDEF:go=data,' + str(baseline[rrdConstants.GO]) + ',GT,data,0,IF',
'VDEF:last=data,LAST',
'AREA:data#D4E157:% Carga CPU Promedio',
'AREA:ready#42A5F5:Ready',
'AREA:set#FFEE58:Set',
'AREA:go#EF5350:Go',
'HRULE:' + str(baseline[rrdConstants.READY]) + '#2979FF',
'HRULE:' + str(baseline[rrdConstants.SET]) + '#FFEA00',
'HRULE:' + str(baseline[rrdConstants.GO]) + '#FF1744',
'PRINT:last:%6.2lf'
)['print[0]']
def graficarObjectsRRD(nombre):
ultima_lectura = int(rrdtool.last("rrd/"+nombre+".rrd"))
tiempo_final = ultima_lectura
tiempo_inicial = tiempo_final-600
ret = rrdtool.graphv( "png/"+nombre+".png",
"--start",str(tiempo_inicial),
"--end",str(tiempo_final),
"--title=Uso de CPU",
"--color",
"ARROW#009900",
'--vertical-label', "Uso de CPU (%)",
'--lower-limit', '0',
'--upper-limit', '100',
"DEF:outTrafic=rrd/"+nombre+".rrd:outoctets:AVERAGE",
"CDEF:umbral25=outTrafic,25,LT,0,outTrafic,IF",
"CDEF:umbral50=outTrafic,50,LT,0,outTrafic,IF",
"CDEF:umbral75=outTrafic,75,LT,0,outTrafic,IF",
"VDEF:m=outTrafic,LSLSLOPE",
"VDEF:b=outTrafic,LSLINT",
"CDEF:tendencia=outTrafic,POP,m,COUNT,*,b,+",
#"CDEF:tendenciaPred=tendencia,90,LT,0,tendencia,IF",
#"CDEF:tendenciaMin=outTrafic,POP,m,COUNT,*,b,+,3,-",
#"CDEF:tendenciaMax=outTrafic,POP,m,COUNT,*,b,+,3,+",
"VDEF:CPUlast=outTrafic,LAST",
"VDEF:CPUmin=outTrafic,MINIMUM",
"VDEF:CPUavg=outTrafic,AVERAGE",
"VDEF:CPUmax=outTrafic,MAXIMUM",
"VDEF:CPUSTDEV=outTrafic,STDEV",
"GPRINT:CPUlast:%6.2lf %SLAST",
"GPRINT:CPUmin:%6.2lf %SMIN",
"GPRINT:CPUavg:%13.0lf%SAVG",
"GPRINT:CPUmax:%6.2lf %SMAX",
"GPRINT:CPUSTDEV:%6.2lf %SSTDEV",
"PRINT:CPUlast:%6.2lf %S",
#"PRINT:tendenciaPred:%6.2lf %S",
"AREA:outTrafic#005500:Carga de cpu",
"AREA:umbral25#00FF00:Tráfico de carga mayor que min",
"AREA:umbral50#FFBB00:Tráfico de carga mayor que avg",
"AREA:umbral75#FF0000:Tráfico de carga mayor que max",
"HRULE:63#00FF00:Umbral ready",
"HRULE:78#FFBB00:Umbral set",
"HRULE:85#FF0000:Umbral go"
#"LINE1:tendenciaMin#00FF00",
#"LINE1:tendenciaMax#FF0000",
)
#print(ret['print[0]'])
ultimo_valor=[float(ret['print[0]']),float(63),float(78),float(85)]
return ultimo_valor
def get_url(self):
"""Return url for displaying graph"""
cached_image = cache.get(repr(self))
if cached_image:
return cached_image
try:
image = rrdtool.graphv(*self._get_graph_args())['image']
except rrdtool.error, error:
_LOGGER.error(error)
def get_url(self):
"""Return url for displaying graph"""
cached_image = cache.get(repr(self))
if cached_image:
return cached_image
try:
image = rrdtool.graphv(*self._get_graph_args())['image']
except rrdtool.error, error:
_LOGGER.error(error)
def graph(name, grouped, period):
" Graph endpoint, returns generated graph "
pd = "-1" + period
if grouped == "i":
test = rrdtool.graphv(
"-", "--start", pd, "-w 800", "--title=Температуры %s" % name,
"-u 60", "-l 15", "DEF:cpu_temp=rrd/%s.rrd:ds0:MAX" % name,
"DEF:hdd_temp=rrd/%s.rrd:ds1:MAX" % name,
"LINE1:cpu_temp#0000FF:Процессор", "LINE2:hdd_temp#FF0000:Диск\\j",
"CDEF:unavailable=cpu_temp,UN,INF,0,IF", "AREA:unavailable#f0f0f0",
"GPRINT:cpu_temp:MAX:Максимум\\: процессор\\: %3.0lf °C",
"GPRINT:hdd_temp:MAX:жёсткий диск\\: %3.0lf °C\\j",
"GPRINT:cpu_temp:AVERAGE:Среднее\\: процессор\\: %3.0lf °C",
"GPRINT:hdd_temp:AVERAGE:жёсткий диск\\: %3.0lf °C\\j",
"GPRINT:cpu_temp:LAST:Последнее\\: процессор\\: %3.0lf °C",
"GPRINT:hdd_temp:LAST:жёсткий диск\\: %3.0lf °C\\j")
else:
names = glob.glob("./rrd/%s*.rrd" % name)
names.sort()
new_names = []
for i in names:
new_names.append(i.replace('./rrd/', '').replace('.rrd', ''))
arguments = ("-", "--start", pd, "-w 800",
"--title=Температуры %s" % name, "-u 60", "-l 15")
j = 1
for i in new_names:
new_arguments = (
"DEF:cpu_temp%d=rrd/%s.rrd:ds0:MAX" % (j, i),
"DEF:hdd_temp%d=rrd/%s.rrd:ds1:MAX" % (j, i),
"LINE1:cpu_temp%d#00%02xFF: %s процессор" % (j, j * 8, i),
"LINE2:hdd_temp%d#FF%02x00:диск\\j" % (j, j * 8),
"GPRINT:cpu_temp%d:MAX:Максимум\\: процессор\\: %%3.0lf °C" %
(j),
"GPRINT:hdd_temp%d:MAX:жёсткий диск\\: %%3.0lf °C\\j" % (j))
j = j + 1
arguments = arguments + new_arguments
# Add arguments
test = rrdtool.graphv(*arguments)
response.set_header('Content-type', 'image/png')
return str(test['image'])
def linebase(tiempo_inicial, tiempo_final, val_max, imagepath, pathrrd):
#extrae la informacion del ultimo dato en net3.rrd
#ultima_lectura = int(rrdtool.last("netPr.rrd"))
val_max = 100 #Valor de procesamiento maximo del CPU
val_desv = 5.70 #Valor de la desviacion estandar
val_def = 60 #Valor a monitorear del CPU
imagepath = imagepath + "Libase.png"
ret = rrdtool.graphv(
imagepath,
"--start",
str(tiempo_inicial),
"--end",
str(tiempo_final),
"--vertical-label=Porcentraje uso CPU",
"--lower-limit",
"0", #Valor menor a graficar
"--upper-limit",
"100", #Valor maximo a graficar
"DEF:entrada=" + str(pathrrd) + ":cpu:AVERAGE", #Promedio de inoctets
#"DEF:outoctets=net3.rrd:outoctets:AVERAGE", #Promedio de outoctets
#Escalar valores a graficar de inoctets
"CDEF:entrada5=entrada," + str(val_max) +
",GT,0,entrada,IF", #Definimos el valor maximo
"VDEF:entradaMAX=entrada,MAXIMUM", #Obtiene el val maximo de entrada
"VDEF:entradaMIN=entrada,MINIMUM", #Obtiene el val minimo de entrada
"VDEF:entradaSTDEV=entrada,STDEV", #Obtiene el val stdev de entrada
"VDEF:entradaLAST=entrada,LAST", #Obtiene el val last de entrada
"AREA:entrada#00FF00:Uso de CPU", #Etiqueta entrada
"HRULE:" + str(val_max) + "#FF0000:Umbral 1", #Etiqueta umbral
"HRULE:" + str(val_def) + "#0000FF:Umbral 2",
"HRULE:" + str(val_desv) + "#0000FF:Umbral 3",
"GPRINT:entradaMAX:%6.2lf %SMAX", #Etiqueta val max
"GPRINT:entradaMIN:%6.2lf %SMIN", #Etiqueta val min
"GPRINT:entradaSTDEV:%6.2lf %SSTDEV", #Etiqueta stdev
"GPRINT:entradaLAST:%6.2lf %SLAST")
lista = []
lista = list(ret.items())
max = str(lista[16])
min = str(lista[18])
print(max, min)
if max.find(str(val_def)) >= 0: #Comparamos si sobre pasa el val_max
print("El valor sobrepasa", max)
#Envio de correo
send_alert_attached(
"Los valores del CPU sobreapasan al " + str(val_def) +
" con un valor de : " + max, imagepath)
#Si el valor minimo es menor que la desviacion estandard
if min.find(str(val_desv)) >= 0:
print("El valor es minimo")
send_alert_attached(
"Los valores del CPU son menores a " + str(val_desv) +
" con un valor de : " + min, imagepath)
def Graficar(nombre, titulo, label, dato):
ultimo = rrdtool.last("RRDsAgentes/monitoreo.rrd")
tiempo_inicial = ultimo
ret2 = rrdtool.graphv(
"Graficas/" + nombre + ".png", "--start", str(tiempo_inicial - 180),
"--title", titulo, "--vertical-label=" + label, '--lower-limit', '0',
'--upper-limit', '100',
"DEF:carga=RRDsAgentes/monitoreo.rrd:" + dato + ":AVERAGE",
"VDEF:cargaMAX=carga,MAXIMUM", "VDEF:cargaMIN=carga,MINIMUM",
"VDEF:cargaLAST=carga,LAST", "AREA:carga#00FF00:Carga del CPU",
"GPRINT:cargaMIN:%6.2lf %SMIN", "GPRINT:cargaMAX:%6.2lf %SMAX",
"GPRINT:cargaLAST:%6.2lf %SACTUAL")
def graph(hostname, period):
test = rrdtool.graphv("-", "--start", period_conv(period), "-w 800", "--title=User count %s" % hostname,
"DEF:users=rrds/%s_users.rrd:users:MAX" % (hostname) ,
"DEF:usersa=rrds/%s_users.rrd:users:AVERAGE" % (hostname) ,
"DEF:uptime=rrds/%s_uptime.rrd:uptime:LAST" % (hostname) ,
"CDEF:users_m=users,UN,0,users,IF",
"LINE2:users_m#0000FF:Users max",
"LINE2:usersa#00FFFF:Users average",
"CDEF:unavailable=uptime,UN,INF,0,IF",
"AREA:unavailable#f0f0f0",
)
return test['image']
def graph(hostname, period):
test = rrdtool.graphv(
"-",
"--start",
period_conv(period),
"-w 800",
"--title=Uptime %s" % hostname,
"DEF:uptime=rrds/%s_uptime.rrd:uptime:LAST" % (hostname),
"LINE1:uptime#0000FF:Uptime",
"CDEF:unavailable=uptime,UN,INF,0,IF",
"AREA:unavailable#f0f0f0",
)
return test['image']
def test_callback_args(self):
"""
Test whether all required arguments are passed in kwargs.
"""
def my_callback(*args, **kwargs):
required_args = ('filename', 'cf', 'start', 'end', 'step')
for k in required_args:
self.assertIn(k, kwargs)
items = int((kwargs['end'] - kwargs['start']) / kwargs['step'])
return {
'start': kwargs['start'],
'step': 300,
'data': {
'a': [math.sin(x / 200) for x in range(0, items)],
'b': [math.cos(x / 200) for x in range(10, items)],
'c': [math.sin(x / 100) for x in range(100, items)],
}
}
rrdtool.register_fetch_cb(my_callback)
rrdtool.graphv(*self.graphv_args)
def graficarMinimosCuadrados (nombre):
ultima_lectura = int(rrdtool.last("rrd/"+nombre+".rrd"))
tiempo_final = ultima_lectura
#tiempo_inicial = tiempo_final-600
tiempo_inicial = 1539658453
ret = rrdtool.graphv( "png/"+nombre+"MinCua.png",
"--start",str(tiempo_inicial),
"--end",str(tiempo_final+4000),
"--title=Uso de CPU",
"--color",
"ARROW#009900",
'--vertical-label', "Uso de CPU (%)",
'--lower-limit', '0',
'--upper-limit', '100',
"DEF:outTrafic=rrd/"+nombre+".rrd:CPUload:AVERAGE",
"VDEF:m=outTrafic,LSLSLOPE",
"VDEF:b=outTrafic,LSLINT",
"VDEF:CPUmax=outTrafic,MAXIMUM",
"CDEF:tendencia=outTrafic,POP,m,COUNT,*,b,+",
"CDEF:limites=tendencia,90,100,LIMIT",
"VDEF:limite1=limites,FIRST",
"VDEF:limite2=limites,LAST",
"VDEF:CPUlast=outTrafic,LAST",
"PRINT:CPUlast:%6.2lf %S",
#"AREA:outTrafic#005500:Carga de cpu",
"HRULE:90#00FF00",
"AREA:limites#FFBB0077",
#"AREA:limite1#00000077:limite1",
#"AREA:tendencia#FFBB0077",
#"LINE2:tendencia#FFBB00",
"AREA:outTrafic#005500:Carga de cpu",
"LINE1:tendencia#FFBB00:dashes=3:Tendencia",
#"AREA:limite1#FFFFFF",
"GPRINT:limite1: limite 1 %c :strftime",
"GPRINT:limite1: limite 1 %6.2lf %S",
#"GPRINT:limite2: \nlimite2 %c \\n:strftime",
#"GPRINT:limite2: limite2 %6.2lf %S"
)
#print(ret['print[0]'])
ultimo_valor=float(ret['print[0]'])
return ultimo_valor
def graph(hostname, period):
test = rrdtool.graphv("-", "--start", period_conv(period), "-w 800", "--title=Ansible %s" % hostname,
"DEF:ok=rrds/%s_ansible.rrd:ok:LAST" % (hostname),
"DEF:change=rrds/%s_ansible.rrd:change:LAST" % (hostname),
"DEF:unreachable=rrds/%s_ansible.rrd:unreachable:LAST" % (hostname),
"DEF:failed=rrds/%s_ansible.rrd:failed:LAST" % (hostname),
"LINE2:ok#00FF00:ok",
"LINE2:change#FFFF00:change",
"LINE3:unreachable#0000FF:unreachable",
"LINE4:failed#FF0000:failed",
"CDEF:unavailable=ok,UN,INF,0,IF",
"AREA:unavailable#f0f0f0",
)
return test['image']
def graph(hostname, period):
test = rrdtool.graphv(
"-",
"--start",
period_conv(period),
"-w 800",
"--title=/scratch %s" % hostname,
"DEF:free=rrds/%s_scratch.rrd:free:LAST" % (hostname),
"DEF:total=rrds/%s_scratch.rrd:total:LAST" % (hostname),
"LINE2:total#009F00:Total",
"LINE2:free#FF00FF:Free",
"CDEF:unavailable=total,UN,INF,0,IF",
"AREA:unavailable#f0f0f0",
)
return test['image']
def graficarRRD(nombre, i):
tiempo_final = int(rrdtool.last("files/" + nombre + ".rrd"))
lateral = "";
if nombre == C.CPU_NAME:
lateral = "--vertical-label=%"
else:
lateral = "--vertical-label=Bytes"
tiempo_inicial = int(rrdtool.first("files/" + nombre + ".rrd"))
ret = rrdtool.graphv("images/" + nombre + ".png",
"--start", str(tiempo_inicial + 6800),
"--end", str(tiempo_final),
lateral,
"DEF:"+nombre+"=files/" + nombre + ".rrd:"+"cosa"+":AVERAGE",
"AREA:"+nombre+"#00FF00:" + nombre)
return
def draw_graph(ifce, timestamp):
graph_slug = ifce['slug']
graph_type = ifce['type']
graph_title = "%s:%s:%s"%(graph_type, ifce['name'], ifce['host'])
graph_subtitle = "algorithm:%s threshold:%s "%(ifce['DETECTION_ALGO'], "%s" %(100*ifce['THRESHOLD']))+"%"
graph_time = "%s" %timestamp
tool_version = VERSION
graph_time_timestamp = "%s" %int(time.mktime(timestamp.timetuple()))
graph_ds = GRAPH_TYPES[graph_type]
graph_legends = GRAPH_TITLES[graph_type]
graph_options = GRAPH_OPTIONS[graph_type]
graph_colors = GRAPH_COLORS[graph_type]
vertical_legend = GRAPH_VERTICAL_LEGEND[graph_type]
graph_multipliers = GRAPH_CDEF_MULTIPLIERS[graph_type]
rrdpath = "%s/%s.rrd" %(RRD_LOCATION, graph_slug)
imgpath = "%s/%s_%s.png" %(RRD_LOCATION, graph_slug, graph_time_timestamp)
graph_args = [str("%s" %imgpath),
"--start", "-3h",
"--width", "800",
"--height", "600",
"-t", "%s\n<span size='x-small'>%s</span>"%(graph_title,graph_subtitle),
"--pango-markup",
"--vertical-label", "%s"%vertical_legend,
"--watermark", "%s - rady %s" %(graph_time, tool_version),
]
for i, gds in enumerate(graph_ds):
graph_args.append(str("DEF:ds%s=%s:ds%s:AVERAGE"%(gds,rrdpath,i)))
if GRAPH_EMBED_AND_SHIFT:
graph_args.append(str("DEF:last3hds%s=%s:ds%s:AVERAGE:end=now-3h:start=end-3h"%(gds,rrdpath,i)))
graph_args.append(str("CDEF:%s=ds%s,%s,*"%(gds,gds,graph_multipliers[i])))
if GRAPH_EMBED_AND_SHIFT:
graph_args.append(str("CDEF:last3h%s=last3hds%s,%s,*"%(gds,gds,graph_multipliers[i])))
graph_args.append(str("SHIFT:last3h%s:10800"%(gds)))
graph_args.append(str("VDEF:max%s=%s,MAXIMUM"%(gds,gds)))
if GRAPH_EMBED_AND_SHIFT:
graph_args.append(str("%s:last3h%s%s:%s (3h ago)\\n"%(graph_options[i], gds ,invertHex(graph_colors[i])+"88", graph_legends[i])))
graph_args.append(str("%s:%s%s:%s\\n"%(graph_options[i], gds ,graph_colors[i]+"dd", graph_legends[i])))
gprint = "GPRINT:max%s" %gds + ":Max\:%8.2lf %s"
graph_args.append(str("%s"%(gprint)))
graph_args.append(str("GPRINT:max%s:" %gds +"at %c\\g:strftime"))
graph_args.append(str("COMMENT:\\n"))
if i == 0:
dashline = "-"*120
graph_args.append(str("COMMENT:%s\\n"%dashline))
#graph_args[-1] = "%s\\r"%graph_args[-1]
args=[str(val) for val in graph_args]
return rrdtool.graphv(*args)
def graficarCPU(agente: Agente, n):
"""Gráfica una BD de RRDTOOL
Usa la calse de Email para enviar un correo
en caso de pasar un umbral"""
global ENVIO
UMBRALCPUMED = 9
UMBRALCPU = 10
ultima_lectura = int(rrdtool.last(RUTARRD+agente.ip+"CPU"+str(n)+".rrd"))
tiempo_final = ultima_lectura
tiempo_inicial = tiempo_final - 600
try:
ret = rrdtool.graphv( RUTAGRA+"CPU"+str(n)+".png",
"--start",str(tiempo_inicial),
"--end",str(tiempo_final),
"--vertical-label=Cpu load",
'--lower-limit', '0',
'--upper-limit', '100',
"DEF:cargaCPU="+RUTARRD+agente.ip+"CPU"+str(n)+".rrd:CPU"+str(n)+"load:AVERAGE",
"CDEF:umbral1=cargaCPU,"+str(UMBRALCPU)+",LT,0,cargaCPU,IF",
"CDEF:umbral=cargaCPU,"+str(UMBRALCPUMED)+",LT,0,cargaCPU,IF",
"VDEF:cargaMAX=cargaCPU,MAXIMUM",
"VDEF:cargaMIN=cargaCPU,MINIMUM",
"VDEF:cargaSTDEV=cargaCPU,STDEV",
"VDEF:cargaLAST=cargaCPU,LAST",
"AREA:cargaCPU#00FF00:Carga Normal del CPU",
"AREA:umbral#FF9F00:Carga CPU mayor que "+str(UMBRALCPUMED),
"AREA:umbral1#FF0000:Carga CPU mayor que "+str(UMBRALCPU),
"HRULE:"+str(UMBRALCPU)+"#FF0000:Umbral - Oh, no "+str(UMBRALCPU),
"PRINT:cargaLAST:%6.2lf",
"GPRINT:cargaMIN:%6.2lf %SMIN",
"GPRINT:cargaSTDEV:%6.2lf %SSTDEV",
"GPRINT:cargaLAST:%6.2lf %SLAST" )
#Obtener el último valor de la gráfica.
ultimo_valor=float(ret['print[0]'])
#print('Último valor '+ str(ultimo_valor))
if (ultimo_valor>UMBRALCPU and ENVIO[0]):
print('El CPU '+str(n)+' del agente '+agente.ip+' se está quemando, corre!!! D=')
ENVIO[0] = False
#send_alert_attached("Sobrepasa Umbral línea base CPU", "CPU"+str(n)+".png")
except Exception as e:
print('Error al momento de graficar CPU: '+ str(e))
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 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 create_file(self):
"""Flush the rrd_cache if it's necessary, then get the rrd-config, generate the graph(s) and merge them to a single file"""
graphs = []
if not self.end or self.end > time.time() - self.__rrd_update_interval:
self.flush_rrd_cache()
if self.output_format == 'csv':
for tmpl_params in self.template.rrd_params:
graphs.append(rrdtool.xport(*tmpl_params))
self._file = self.merge_files(graphs)
else:
for tmpl_params in self.template.rrd_params:
graphs.append(rrdtool.graphv('-', *tmpl_params))
self._file = self.merge_files(graphs)
if not self._file:
PyNPException('No graph was generated')
def graphTCP():
ultima_lectura = int(rrdtool.last("trendTCP.rrd"))
tiempo_final = ultima_lectura
tiempo_inicial = tiempo_final - 600
ret = rrdtool.graphv(
"deteccionTCP.png", "--start", str(tiempo_inicial), "--end",
str(tiempo_final), "--vertical-label=TCP load", '--lower-limit', '0',
'--upper-limit', '2', "DEF:cargaTCP=trendTCP.rrd:TCPload:AVERAGE",
"CDEF:umbral30=cargaTCP,1.7,LT,0,cargaTCP,IF",
"VDEF:cargaMAX=cargaTCP,MAXIMUM", "VDEF:cargaMIN=cargaTCP,MINIMUM",
"VDEF:cargaSTDEV=cargaTCP,STDEV", "VDEF:cargaLAST=cargaTCP,LAST",
"AREA:cargaTCP#00FF00:Carga del TCP",
"AREA:umbral30#FF9F00:Carga TCP mayor que maxbw",
"HRULE:1.7#00FF00:Umbral 1", "PRINT:cargaLAST:%6.2lf %SLAst",
"GPRINT:cargaMIN:%6.2lf %SMIN", "GPRINT:cargaSTDEV:%6.2lf %SSTDEV",
"GPRINT:cargaLAST:%6.2lf %SLAST")
def graph(hostname, period):
test = rrdtool.graphv(
"-",
"--start",
period_conv(period),
"-w 800",
"--title=Load %s" % hostname,
"DEF:load=rrds/%s_cpu.rrd:load:MAX" % (hostname),
"DEF:cores=rrds/%s_cpu.rrd:cores:LAST" % (hostname),
"DEF:loadavg=rrds/%s_cpu.rrd:loadavg:LAST" % (hostname),
"CDEF:load100=load,100,/",
"LINE2:load#0000FF:load",
"LINE2:cores#00FFFF:cores",
"LINE2:loadavg#FF00FF:loadavg",
"CDEF:unavailable=load,UN,INF,0,IF",
"AREA:unavailable#f0f0f0",
)
return test['image']
def makeNetworkGraph(root, startTime, endTime=rrdConstants.NOW):
shift = int(rrdConstants.HW_PERIOD) * int(rrdConstants.STEP)
shiftedStart = int(startTime) - shift
shiftedEnd = int(endTime) - shift
shiftedStart = str(shiftedStart)
shiftedEnd = str(shiftedEnd)
shift = str(shift)
return rrdtool.graphv(
root + '/' + rrdConstants.NETWORK_GRAPH, '--imgformat', 'PDF',
'--start', startTime, '--end', endTime, '--width',
rrdConstants.GRAPH_WIDTH, '--height', rrdConstants.GRAPH_HEIGHT,
'--full-size-mode', '--title', 'Ancho de Banda de Entrada',
'--vertical-label', 'bits/s', 'DEF:data=' + root + '/' +
rrdConstants.HW_FILENAME + ':' + rrdConstants.DS_NETWORK + ':AVERAGE',
'DEF:prev=' + root + '/' + rrdConstants.HW_FILENAME + ':' +
rrdConstants.DS_NETWORK + ':AVERAGE:start=' + shiftedStart + ':end=' +
shiftedEnd, 'DEF:pred=' + root + '/' + rrdConstants.HW_FILENAME + ':' +
rrdConstants.DS_NETWORK + ':HWPREDICT', 'DEF:dev=' + root + '/' +
rrdConstants.HW_FILENAME + ':' + rrdConstants.DS_NETWORK +
':DEVPREDICT', 'DEF:fail=' + root + '/' + rrdConstants.HW_FILENAME +
':' + rrdConstants.DS_NETWORK + ':FAILURES', 'VDEF:last=fail,LAST',
'VDEF:maxDev=dev,MAXIMUM', 'CDEF:upper=pred,dev,2,*,+',
'CDEF:lower=pred,dev,2,*,-', 'CDEF:printDev=dev,maxDev,-',
'VDEF:firstData=data,FIRST', 'VDEF:lastData=data,LAST',
'GPRINT:firstData:Desde %d/%m/%Y %H\:%M\:%S:strftime',
'GPRINT:lastData:Hasta %d/%m/%Y %H\:%M\:%S\c:strftime',
'TICK:fail#FFEB3B:1.0: Fallos\c', 'SHIFT:prev:' + shift,
'AREA:prev#e0e0e0CC:Periodo Anterior\t', 'VDEF:totalPrev=prev,TOTAL',
'VDEF:maxPrev=prev,MAXIMUM', 'VDEF:avgPrev=prev,AVERAGE',
'GPRINT:totalPrev:Total\:\t%0.3lf%s',
'GPRINT:maxPrev:Máximo\:\t%0.3lf%s',
'GPRINT:avgPrev:Promedio\: %0.3lf%s\c',
'LINE2:data#0091EA:Ancho de Banda\t', 'VDEF:totalData=data,TOTAL',
'VDEF:maxData=data,MAXIMUM', 'VDEF:avgData=data,AVERAGE',
'GPRINT:totalData:Total\:\t%0.3lf%s',
'GPRINT:maxData:Máximo\:\t%0.3lf%s',
'GPRINT:avgData:Promedio\: %0.3lf%s\c', 'LINE2:pred#FF4081:Predicción',
'LINE1:upper#D50000:Límite Superior',
'LINE1:lower#64DD17:Límite Inferior',
'LINE1:printDev#000000:Desviación\c', 'PRINT:last:%1.0lf')['print[0]']
def makeNetworkGraph(root, startTime, endTime=rrdConstants.NOW):
return rrdtool.graphv(
root + '/' + rrdConstants.NETWORK_GRAPH, '--imgformat', 'PDF',
'--start', startTime, '--end', endTime, '--width',
rrdConstants.GRAPH_WIDTH, '--height', rrdConstants.GRAPH_HEIGHT,
'--full-size-mode', '--title', 'Ancho de Banda de Entrada',
'--vertical-label', 'bits/s', 'DEF:data=' + root + '/' +
rrdConstants.HW_FILENAME + ':' + rrdConstants.DS_NETWORK + ':AVERAGE',
'DEF:pred=' + root + '/' + rrdConstants.HW_FILENAME + ':' +
rrdConstants.DS_NETWORK + ':HWPREDICT',
'DEF:dev=' + root + '/' + rrdConstants.HW_FILENAME + ':' +
rrdConstants.DS_NETWORK + ':DEVPREDICT', 'DEF:fail=' + root + '/' +
rrdConstants.HW_FILENAME + ':' + rrdConstants.DS_NETWORK + ':FAILURES',
'VDEF:last=fail,LAST', 'CDEF:upper=pred,dev,2,*,+',
'CDEF:lower=pred,dev,2,*,-', 'TICK:fail#F4433666:1.0: Fallos',
'LINE2:data#64DD17:Ancho de Banda Promedio',
'LINE1:upper#D50000:Limite Superior',
'LINE1:lower#0091EA:Limite Inferior', 'PRINT:last:%1.0lf')['print[0]']
def generate_plot(rrdfile, start, end, ds):
r, w = os.pipe()
pid = os.fork()
if pid:
os.close(w)
r = os.fdopen(r, 'rb')
image = r.read()
os.waitpid(pid, 0)
else:
os.close(r)
w = os.fdopen(w, 'wb')
imagedata = rrdtool.graphv("-", '--end', "%d" % (end), '--start',
"%d" % (start),
"DEF:myspeed=%s:%s:AVERAGE" % (rrdfile, ds),
'LINE1:myspeed#FF0000')
w.write(imagedata['image'])
w.close()
os._exit(0)
return image
def makeMemoryGraph(root, startTime, endTime=rrdConstants.NOW):
baseline = rrdConstants.BASELINE[rrdConstants.DS_MEMORY]
return rrdtool.graphv(
root + '/' + rrdConstants.MEMORY_GRAPH, '--start', startTime, '--end',
endTime, '--width', rrdConstants.GRAPH_WIDTH, '--height',
rrdConstants.GRAPH_HEIGHT, '--full-size-mode', '--title',
'Porcentage de uso de memoria.', '--vertical-label', '% Memoria',
'--lower-limit', '0', '--upper-limit', '100', 'DEF:data=' + root +
'/' + 'perf.rrd' + ':' + rrdConstants.DS_MEMORY + ':AVERAGE',
'CDEF:ready=data,' + str(baseline[rrdConstants.READY]) +
',GT,data,0,IF',
'CDEF:set=data,' + str(baseline[rrdConstants.SET]) + ',GT,data,0,IF',
'CDEF:go=data,' + str(baseline[rrdConstants.GO]) + ',GT,data,0,IF',
'VDEF:last=data,LAST', 'AREA:data#D4E157:% Memoria utilizada',
'AREA:ready#42A5F5:Ready', 'AREA:set#FFEE58:Set', 'AREA:go#EF5350:Go',
'HRULE:' + str(baseline[rrdConstants.READY]) + '#2979FF',
'HRULE:' + str(baseline[rrdConstants.SET]) + '#FFEA00',
'HRULE:' + str(baseline[rrdConstants.GO]) + '#FF1744',
'PRINT:last:%6.2lf')['print[0]']
def generate_plot(rrdfile, start, end, ds):
r, w = os.pipe()
pid = os.fork()
if pid:
os.close(w)
r = os.fdopen(r,'rb')
image = r.read()
os.waitpid(pid,0)
else:
os.close(r)
w = os.fdopen(w,'wb')
imagedata = rrdtool.graphv("-",
'--end', "%d" % (end),
'--start', "%d" % (start),
"DEF:myspeed=%s:%s:AVERAGE" % (rrdfile,ds),
'LINE1:myspeed#FF0000')
w.write(imagedata['image'])
w.close()
os._exit(0)
return image
def graph(request):
project_dir="/home/pi/virtualenvs/BrewPi"
displayhours=2
args=""
width=600
height=400
if request.method == 'GET':
try:
displayhours = int(request.GET['hours'])
except:
pass
try:
width = int(request.GET['width'])
except:
pass
try:
height = int(request.GET['height'])
except:
pass
arg=["",""]
#
file=rrdtool.graphv("-","--start",
"-" + str(displayhours) + "h",
"--vertical-label=Temperature (C)",
"-w" + str(width),
"-h" + str(height),
"-D",
"-Y",
"DEF:HLT_Temp=" + project_dir + "/rrd/temps.rrd:temp_HLT:AVERAGE",
"LINE1:HLT_Temp#00FF00:HLT Temperature",
"CDEF:unavailable=HLT_Temp,UN,INF,0,IF",
"AREA:unavailable#d0d0d0")
return HttpResponse(file['image'], mimetype="image/png")
def create_graph_for_interfaces(datasources, start=None, end=None, **kwargs):
if 'dryrun' in kwargs:
dryrun = kwargs['dryrun']
else:
dryrun = False
if not start:
start = '-1d'
if not end:
end = '-100'
if datasources:
name = os.path.basename(datasources[0].rrdfile.path).split('.')
if name[0]:
name = name[0]
else:
name = name[1]
title = '%s to %s' % (name.split('-')[0], name.split('-')[1])
arguments = ['%s/%s%s%s.png' % (settings.RG_STATICPATH, name, start, end)]
if hasattr(settings, 'RG_RRDCACHED'):
arguments.append('--daemon=%s' % str(settings.RG_RRDCACHED))
arguments.append('-s %s' % start)
arguments.append('-e %s' % end)
arguments.append('-t %s' % title)
arguments.append('--slope-mode')
arguments.append('-l 0')
aggregate_dict = {'ds0': [], 'ds1': []}
interfaces_dict = {
'ds0': {
'label': 'In ',
'color': '#0000ff',
'graph_type': 'AREA'
},
'ds1': {
'label': 'Out',
'color': '#00ff00',
'graph_type': 'LINE'
}
}
legend = []
used_ds = []
for d in datasources:
if d.pk not in used_ds:
arguments.append('DEF:d%s=%s:%s:AVERAGE' % (d.pk, d.rrdfile.path, d.name))
arguments.append('DEF:%smax=%s:%s:MAX' % (d.pk, d.rrdfile.path, d.name))
aggregate_dict[d.name].append(d.pk)
arguments.append('CDEF:d%sdispAVG=d%s,8,*' % (d.pk, d.pk))
used_ds.append(d.pk)
arguments.append('COMMENT:\t\tMin\g')
arguments.append('COMMENT:\tMax\g')
arguments.append('COMMENT:\tAverage\g')
arguments.append('COMMENT:\tCurrent\\n')
for key, val in aggregate_dict.iteritems():
arguments.append('CDEF:aggr%s=' % (key))
legend.append('%s:aggr%s%s:%s' % (
interfaces_dict.get(key).get('graph_type'), key, interfaces_dict.get(key).get('color'), interfaces_dict.get(key).get('label'))
)
for rrd in val:
arguments[-1] += 'd%sdispAVG,' % rrd
if rrd != val[0]:
arguments[-1] += 'ADDNAN,'
legend.append('%s:aggr%s:%s:%s' % ('GPRINT', key, 'MIN', '\t%4.2lf%s\g'))
legend.append('%s:aggr%s:%s:%s' % ('GPRINT', key, 'MAX', '\t%4.2lf%s\g'))
legend.append('%s:aggr%s:%s:%s' % ('GPRINT', key, 'AVERAGE', '\t%4.2lf%s\g'))
legend.append('%s:aggr%s:%s:%s' % ('GPRINT', key, 'LAST', '\t%4.2lf%s\\n'))
arguments.extend(legend)
args = [str(val) for val in arguments]
if dryrun == True:
import re
for ri in range(len(args)):
if args[ri].find('-') == 0 and \
len(args[ri].split()) > 2:
larg = args[ri].split()
larg[1] = "'" + larg[1]
larg[-1] = larg[-1] + "'"
args[ri] = ' '.join(larg)
elif bool(re.search(r'^([CV]?DEF|AREA|GPRINT|COMMENT|HRULE):',
args[ri])):
args[ri] = "'%s'" % args[ri]
return ' \n'.join('rrdtool graph'.split() + args)
else:
rrdtool.graphv(*args)
url = reverse(
'get-png-data',
kwargs={
'path': '%s%s%s.png' % (name, start, end)
}
)
return url
return False
def graph(self):
params = self.common_params()
params += self.get_period()
params.extend(self.gen_params())
return rrdtool.graphv(*params)
def graph_rrdtool(self,stime):
if stime == '-1d':
perfix = '1d_'
graph_cpu = perfix+self.graph_cpu
graph_mem = perfix+self.graph_mem
graph_disk = perfix+self.graph_disk
graph_network = perfix+self.graph_network
graph_login = perfix+self.graph_login
elif stime == '-1w':
perfix = '1w_'
graph_cpu = perfix+self.graph_cpu
graph_mem = perfix+self.graph_mem
graph_disk = perfix+self.graph_disk
graph_network = perfix+self.graph_network
graph_login = perfix+self.graph_login
elif stime == '-1M':
perfix = '1m_'
graph_cpu = perfix+self.graph_cpu
graph_mem = perfix+self.graph_mem
graph_disk = perfix+self.graph_disk
graph_network = perfix+self.graph_network
graph_login = perfix+self.graph_login
host = self.host
ISOFORMAT='%Y%m%d'
today = datetime.date.today()
today_dir = today.strftime(ISOFORMAT)
date = time.strftime('%Y-%m-%d',time.localtime(time.time()))
if not os.path.exists(self.graph_dir):
os.mkdir(self.graph_dir)
for i in list(host.split(',')):
os.chdir(self.graph_dir)
if not os.path.exists(i):
os.mkdir(i)
os.chdir(i)
if not os.path.exists(today_dir):
os.mkdir(today_dir)
for j in list(host.split(',')):
os.chdir(self.rrdtool_dir)
os.chdir(j)
#os.chdir(today_dir)
### nic.png
#title = "Network Traffic Flow ("+date+")"
title = "网络流量监控 ("+date+")"
rrdtool.graphv(graph_network,'--start',stime,
'--vertical-label=Bytes/s',
#'--x-grid','MINUTE:12:HOUR:1:HOUR:1:0:%H',
'--font','LEGEND:8:/usr/share/fonts/wqy-microhei/wqy-microhei.ttc',
'--width','1300','--height','460',
'--title',title,
'DEF:input=nic.rrd:input:AVERAGE',
'DEF:output=nic.rrd:output:AVERAGE',
'DEF:ine=nic.rrd:input_err:AVERAGE',
'DEF:oute=nic.rrd:output_err:AVERAGE',
'CDEF:inp=input,8,*',
'CDEF:inerr=ine,8,*',
'CDEF:outp=output,8,*',
'CDEF:outerr=oute,8,*',
'COMMENT:\\r',
'COMMENT:\\r',
'AREA:inp#FFC125:Network Input',
'GPRINT:inp:LAST:Currnet\:%8.2lf %Sbps',
'GPRINT:inp:AVERAGE:Average\:%8.2lf %Sbps',
'GPRINT:inp:MAX:Maxnum\:%8.2lf %Sbps\\n',
'LINE3:inerr#CD2626:Network Output',
'GPRINT:inerr:LAST:Currnet\:%8.2lf %Sbps',
'GPRINT:inerr:AVERAGE:Average\:%8.2lf %Sbps',
'GPRINT:inerr:MAX:Maxnum\:%8.2lf %Sbps\\n',
'LINE3:outp#00FF00:Network Output',
'GPRINT:outp:LAST:Current\:%8.2lf %Sbps',
'GPRINT:outp:AVERAGE:Average\:%8.2lf %Sbps',
'GPRINT:outp:MAX:Maxnum\:%8.2lf %Sbps\\n',
'LINE3:outerr#0000FF:Network Out err',
'GPRINT:outerr:LAST:Current\:%8.2lf %Sbps',
'GPRINT:outerr:AVERAGE:Average\:%8.2lf %Sbps',
'GPRINT:outerr:MAX:Maxnum\:%8.2lf %Sbps\\n')
if not os.path.exists(graph_network):
logging.error('Network png not found. PNG file generated failure.')
else:
k = '/'
dst = self.graph_dir+k+j+k+today_dir
dst_file = dst+k+graph_network
print dst_file
if not os.path.exists(dst_file):
shutil.move(graph_network,dst)
else:
logging.warning("Network png already exists.To be convered.")
os.remove(dst_file)
shutil.move(graph_network,dst)
### cpu.png
#title = "CPU Utilzation rate ("+date+")"
title = "CPU 使用率 ("+date+")"
rrdtool.graphv(graph_cpu,'--start',stime,
'--vertical-label=Bytes/s',
#'--x-grid','MINUTE:12:HOUR:1:HOUR:1:0:%H',
'--font','LEGEND:8:/usr/share/fonts/wqy-microhei/wqy-microhei.ttc',
'--width','1300','--height','460',
'--title',title,
'DEF:a=cpu.rrd:cpu_loadavg_1:AVERAGE',
'DEF:b=cpu.rrd:cpu_loadavg_5:AVERAGE',
'DEF:c=cpu.rrd:cpu_loadavg_15:AVERAGE',
'DEF:user=cpu.rrd:cpu_user:AVERAGE',
'DEF:nic=cpu.rrd:cpu_nice:AVERAGE',
'DEF:system=cpu.rrd:cpu_system:AVERAGE',
'DEF:iowait=cpu.rrd:cpu_iowait:AVERAGE',
'DEF:steal=cpu.rrd:cpu_steal:AVERAGE',
'DEF:idel=cpu.rrd:cpu_idel:AVERAGE',
'COMMENT:\\r',
'COMMENT:\\r',
'LINE3:a#FFC125:Loadavg 1',
'GPRINT:a:LAST:Currnet\:%8.2lf %s',
'GPRINT:a:AVERAGE:Average\:%8.2lf %s',
'GPRINT:a:MAX:Maximum\:%8.2lf %s\\n',
'LINE3:b#EE7600:Loadavg 5',
'GPRINT:b:LAST:Currnet\:%8.2lf %s',
'GPRINT:b:AVERAGE:Average\:%8.2lf %s',
'GPRINT:b:MAX:Maximum\:%8.2lf %s\\n',
'LINE3:c#FF0000:Loadavg 15',
'GPRINT:c:LAST:Currnet\:%8.2lf %s',
'GPRINT:c:AVERAGE:Average\:%8.2lf %s',
'GPRINT:c:MAX:Maximum\:%8.2lf %s\\n',
'LINE3:user#0000FF:CPU User',
'GPRINT:user:LAST:Currnet\:%8.2lf %s',
'GPRINT:user:AVERAGE:Average\:%8.2lf %s',
'GPRINT:user:MAX:Maximum\:%8.2lf %s\\n',
'LINE3:nic#9AC0CD:CPU Nice',
'GPRINT:nic:LAST:Currnet\:%8.2lf %s',
'GPRINT:nic:AVERAGE:Average\:%8.2lf %s',
'GPRINT:nic:MAX:Maximum\:%8.2lf %s\\n',
'LINE3:system#9A32CD:CPU System',
'GPRINT:system:LAST:Currnet\:%8.2lf %s',
'GPRINT:system:AVERAGE:Average\:%8.2lf %s',
'GPRINT:system:MAX:Maximum\:%8.2lf %s\\n',
'LINE3:iowait#999999:CPU Iowait',
'GPRINT:iowait:LAST:Currnet\:%8.2lf %s',
'GPRINT:iowait:AVERAGE:Average\:%8.2lf %s',
'GPRINT:iowait:MAX:Maximum\:%8.2lf %s\\n',
'LINE3:steal#9AC0CD:CPU Steal',
'GPRINT:steal:LAST:Currnet\:%8.2lf %s',
'GPRINT:steal:AVERAGE:Average\:%8.2lf %s',
'GPRINT:steal:MAX:Maximum\:%8.2lf %s\\n',
'LINE3:idel#00CD00:CPU Idel',
'GPRINT:idel:LAST:Currnet\:%8.2lf %s',
'GPRINT:idel:AVERAGE:Average\:%8.2lf %s',
'GPRINT:idel:MAX:Maximum\:%8.2lf %s\\n')
if not os.path.exists(graph_cpu):
logging.error('CPU png not found. PNG file generated failure.')
else:
k = '/'
dst = self.graph_dir+k+j+k+today_dir
dst_file = dst+k+graph_cpu
print dst
print dst_file
if not os.path.exists(dst_file):
shutil.move(graph_cpu,dst)
else:
logging.warning("CPU png already exists.To be convered.")
os.remove(dst_file)
shutil.move(graph_cpu,dst)
### mem.png
#title = "Mem Utilzation ("+date+")"
title = "内存使用情况 ("+date+")"
rrdtool.graphv(graph_mem,'--start',stime,
'--vertical-label=Bytes',
#'--x-grid','MINUTE:12:HOUR:1:HOUR:1:0:%H',
'--font','LEGEND:8:/usr/share/fonts/wqy-microhei/wqy-microhei.ttc',
'--width','1300','--height','460',
'--title',title,
'DEF:memtotal=mem.rrd:mem_total:AVERAGE',
'DEF:memfreed=mem.rrd:mem_freed:AVERAGE',
'DEF:memused=mem.rrd:mem_used:AVERAGE',
'DEF:buffersfreed=mem.rrd:mem_buffers_freed:AVERAGE',
'DEF:buffersused=mem.rrd:mem_buffers_used:AVERAGE',
'DEF:mempercent=mem.rrd:mem_used_percent:AVERAGE',
'DEF:swaptotal=mem.rrd:swap_total:AVERAGE',
'DEF:swapfreed=mem.rrd:swap_freed:AVERAGE',
'DEF:swapused=mem.rrd:swap_used:AVERAGE',
'DEF:swappercent=mem.rrd:swap_used_percnet:AVERAGE',
'CDEF:mtotal=memtotal,1048576,*',
'CDEF:mfreed=memfreed,1048576,*',
'CDEF:mused=memused,1048576,*',
'CDEF:bfreed=buffersfreed,1048576,*',
'CDEF:bused=buffersused,1048576,*',
'CDEF:stotal=swaptotal,1048576,*',
'CDEF:sfreed=swapfreed,1048576,*',
'CDEF:sused=swapused,1048576,*',
'COMMENT:\\r',
'COMMENT:\\r',
'LINE3:mtotal#FFC125:Mem Total',
'GPRINT:mtotal:LAST:Currnet\:%8.2lf %s',
'GPRINT:mtotal:AVERAGE:Average\:%8.2lf %s',
'GPRINT:mtotal:MAX:Maximum\:%8.2lf %s\\n',
'LINE3:mused#CD2626:Mem Used',
'GPRINT:mused:LAST:Currnet\:%8.2lf %s',
'GPRINT:mused:AVERAGE:Average\:%8.2lf %s',
'GPRINT:mused:MAX:Maximum\:%8.2lf %s\\n',
'LINE2:mfreed#00FF00:Mem Freed',
'GPRINT:mfreed:LAST:Currnet\:%8.2lf %s',
'GPRINT:mfreed:AVERAGE:Average\:%8.2lf %s',
'GPRINT:mfreed:MAX:Maximum\:%8.2lf %s\\n',
'LINE3:bfreed#0000FF:Mem Buffers Freed',
'GPRINT:bfreed:LAST:Currnet\:%8.2lf %s',
'GPRINT:bfreed:AVERAGE:Average\:%8.2lf %s',
'GPRINT:bfreed:MAX:Maximum\:%8.2lf %s\\n',
'LINE3:bused#EEEE00:Mem Buffers Used',
'GPRINT:bused:LAST:Currnet\:%8.2lf %s',
'GPRINT:bused:AVERAGE:Average\:%8.2lf %s',
'GPRINT:bused:MAX:Maximum\:%8.2lf %s\\n',
'LINE3:mempercent#EE9A49:Mem Used Percent',
'GPRINT:mempercent:LAST:Currnet\:%8.2lf %s',
'GPRINT:mempercent:AVERAGE:Average\:%8.2lf %s',
'GPRINT:mempercent:MAX:Maximum\:%8.2lf %s\\n',
'LINE3:stotal#B4EEB4:SWAP Total',
'GPRINT:stotal:LAST:Currnet\:%8.2lf %s',
'GPRINT:stotal:AVERAGE:Average\:%8.2lf %s',
'GPRINT:stotal:MAX:Maximum\:%8.2lf %s\\n',
'LINE3:sfreed#B4EEB4:SWAP Freed',
'GPRINT:sfreed:LAST:Currnet\:%8.2lf %s',
'GPRINT:sfreed:AVERAGE:Average\:%8.2lf %s',
'GPRINT:sfreed:MAX:Maximum\:%8.2lf %s\\n',
'LINE3:sused#B4EEB4:SWAP Used',
'GPRINT:sused:LAST:Currnet\:%8.2lf %s',
'GPRINT:sused:AVERAGE:Average\:%8.2lf %s',
'GPRINT:sused:MAX:Maximum\:%8.2lf %s\\n',
'LINE3:swappercent#AAAAAA:SWAP Used Percent',
'GPRINT:swappercent:LAST:Currnet\:%8.2lf %s',
'GPRINT:swappercent:AVERAGE:Average\:%8.2lf %s',
'GPRINT:swappercent:MAX:Maximum\:%8.2lf %s\\n')
if not os.path.exists(graph_mem):
logging.error('MEM png not found. PNG file generated failure.')
else:
k = '/'
dst = self.graph_dir+k+j+k+today_dir
dst_file = dst+k+graph_mem
print dst
print dst_file
if not os.path.exists(dst_file):
shutil.move(graph_mem,dst)
else:
logging.warning("MEM png already exists.To be convered.")
os.remove(dst_file)
shutil.move(graph_mem,dst)
### disk.png
title = "Disk Utilzation ("+date+")"
title = "磁盘使用情况 ("+date+")"
rrdtool.graphv(graph_disk,'--start',stime,
'--vertical-label=Bytes',
#'--x-grid','MINUTE:12:HOUR:1:HOUR:1:0:%H',
'--font','LEGEND:8:/usr/share/fonts/wqy-microhei/wqy-microhei.ttc',
'--width','1300','--height','460',
'--title',title,
'DEF:percent=disk.rrd:disk_used_percent:AVERAGE',
'DEF:used=disk.rrd:disk_used:AVERAGE',
'DEF:freed=disk.rrd:disk_freed:AVERAGE',
'DEF:total=disk.rrd:disk_total:AVERAGE',
'COMMENT:\\r',
'COMMENT:\\r',
'AREA:percent#FFC125:Percent',
'GPRINT:percent:LAST:Currnet\:%8.2lf %s',
'GPRINT:percent:AVERAGE:Average\:%8.2lf %s',
'GPRINT:percent:MAX:Maximum\:%8.2lf %s\\n',
'AREA:used#CD2626:Used',
'GPRINT:used:LAST:Currnet\:%8.2lf %s',
'GPRINT:used:AVERAGE:Average\:%8.2lf %s',
'GPRINT:used:MAX:Maximum\:%8.2lf %s\\n',
'LINE2:freed#00FF00:Freed',
'GPRINT:freed:LAST:Currnet\:%8.2lf %s',
'GPRINT:freed:AVERAGE:Average\:%8.2lf %s',
'GPRINT:freed:MAX:Maximum\:%8.2lf %s\\n',
'LINE3:total#0000FF:Total',
'GPRINT:total:LAST:Currnet\:%8.2lf %s',
'GPRINT:total:AVERAGE:Average\:%8.2lf %s',
'GPRINT:total:MAX:Maximum\:%8.2lf %s\\n')
if not os.path.exists(graph_disk):
logging.error('DISK png not found. PNG file generated failure.')
else:
k = '/'
dst = self.graph_dir+k+j+k+today_dir
dst_file = dst+k+graph_disk
print dst
print dst_file
if not os.path.exists(dst_file):
shutil.move(graph_disk,dst)
else:
logging.warning("DISK png already exists.To be convered.")
os.remove(dst_file)
shutil.move(graph_disk,dst)
### login_user.png
#title = "Lonin User Num ("+date+")"
title = "登陆用户数量 ("+date+")"
rrdtool.graphv(graph_login,'--start',stime,
'--vertical-label=Bytes',
#'--x-grid','MINUTE:12:HOUR:1:HOUR:1:0:%H',
'--font','LEGEND:8:/usr/share/fonts/wqy-microhei/wqy-microhei.ttc',
'--width','1300','--height','460',
'--title',title,
'DEF:o=login_user.rrd:login_user_num:AVERAGE',
'COMMENT:\\r',
'COMMENT:\\r',
'AREA:o#00FF00:Users',
'COMMENT: ',
'GPRINT:o:LAST:Currnet\:%8.0lf',
'COMMENT: ',
'GPRINT:o:AVERAGE:Avg login user num\:%8.0lf',
'COMMENT: ',
'GPRINT:o:MAX:Maximum\:%8.0lf\\n')
if not os.path.exists(graph_login):
logging.error('login png not found. PNG file generated failure.')
else:
k = '/'
dst = self.graph_dir+k+j+k+today_dir
dst_file = dst+k+graph_login
print dst
print dst_file
if not os.path.exists(dst_file):
shutil.move(graph_login,dst)
else:
logging.warning("Login png already exists.To be convered.")
os.remove(dst_file)
shutil.move(graph_login,dst)
rrdtool.graphv("/var/www/elec/%s.png" % k,
'--imgformat', 'PNG',
'--width', '740',
'--height', '140',
'--start', str(v[0]),
'--end', str(v[1]),
'--vertical-label', 'Watts',
'--title', '30 Park Rd, Electricity Usage %s' % k,
'--lower-limit', '0',
'DEF:watts=/var/elec/elec.rrd:joules:AVERAGE',
'CDEF:totaljoules=watts,%d,*' % (v[1]-v[0]),
'CDEF:kWh=totaljoules,3600000,/',
'CDEF:cost=kWh,0.1,*',
'VDEF:MM=watts,MAXIMUM',
'CDEF:s10=watts,150,LT,watts,150,IF',
'CDEF:s20=watts,300,LT,watts,300,IF',
'CDEF:s30=watts,450,LT,watts,450,IF',
'CDEF:s40=watts,800,LT,watts,800,IF',
'CDEF:s50=watts,1500,LT,watts,1500,IF',
'CDEF:s60=watts,3000,LT,watts,3000,IF',
'CDEF:s70=watts',
'CDEF:sh10=s10,MM,LT,watts,MM,IF',
'CDEF:sh20=s20,MM,LT,watts,MM,IF',
'CDEF:sh30=s30,MM,LT,watts,MM,IF',
'CDEF:sh40=s40,MM,LT,watts,MM,IF',
'CDEF:sh50=s50,MM,LT,watts,MM,IF',
'CDEF:sh60=s60,MM,LT,watts,MM,IF',
'CDEF:sh70=s70,MM,LE,watts,MM,IF',
'AREA:sh70#FF0000:',
'AREA:sh60#FF9900:',
'AREA:sh50#FFCC00:',
'AREA:sh40#FFFF00:',
'AREA:sh30#CCFF00:',
'AREA:sh20#99FF00:',
'AREA:sh10#65FF00:',
'VDEF:Average=watts,AVERAGE',
'HRULE:Average#9595FF:Average',
'GPRINT:watts:AVERAGE:Power %4.0lf Watts\\t',
'GPRINT:kWh:AVERAGE:kWh %4.2lf\\t',
'GPRINT:cost:AVERAGE:Cost %3.2lf\\n')
def plot(values, rrd_root, width = None, height = None, timespan = None,
title = None, ylabel = None, ymin = None, ymax = None):
defs = []
lines = []
auto_colour_idx = 0
for v in values:
val_name = v['name']
line_label = val_name
if 'rrd' in v and 'ds' in v:
datasource = v['ds']
rrd_file = os.path.join(rrd_root, v['rrd'])
consolidation_function = "AVERAGE" # let's hope it's there
defs.append(
"DEF:%s=%s:%s:%s" % \
(val_name, rrd_file, datasource, consolidation_function)
)
elif 'expr' in v:
expression = v['expr']
defs.append("CDEF:%s=%s" % (val_name, expression))
if not val_name.startswith("_"):
colour = _AUTO_COLOURS[auto_colour_idx]
auto_colour_idx += 1
lines.append("LINE:%s%s:%s" % (val_name, colour, line_label))
rrd_commands = [
'-', '--imgformat', 'PNG',
]
if width is not None and height is not None:
rrd_commands.extend([
"--full-size-mode",
"--width", "%d" % (width),
"--height", "%d" % (height),
])
if title is not None:
rrd_commands.extend(['--title', str(title)])
if timespan is not None:
rrd_commands.extend([
'--start', 'now - %s' % (timespan,),
'--end', 'now - 1',
])
if ylabel is not None:
rrd_commands.extend(['--vertical-label', ylabel])
if ymin is not None:
rrd_commands.extend(['--lower-limit', str(ymin)])
if ymax is not None:
rrd_commands.extend(['--upper-limit', str(ymax)])
rrd_commands.extend(defs)
rrd_commands.extend(lines)
# make sure it's a string everywhere
for i in range(len(rrd_commands)):
rrd_commands[i] = str(rrd_commands[i])
try:
result = rrdtool.graphv(*rrd_commands)
return result['image']
except rrdtool.error, e:
# XXX: pity I have to discriminate errors this way, but rrdtool
# provides no other way
if e.args[0].startswith('opening'):
raise IOError(e)
else:
raise ValueError(e)
