def process(self):
# Parseo un CGI frame.
# DLGID=TEST01&TYPE=CTL&VER=2.0.6&PLOAD=CLASS:SCAN;UID:304632333433180f000500
# Guardo los datos y de acuerdo al tipo, lo proceso con subclases.
# El raw frame es una linea CGI.
# Al decodificarla y ver cual es su TYPE puedo ver que frame es y comienzo a especializar
# su decodificacion pasandoselo a la clase correspondiente.
form = u_parse_cgi_line(self.query_string)
dlgid = form.get('DLGID', 'SPY000')
version = form.get('VER', 'R0.0.0')
payload_str = form.get('PLOAD', 'ERROR')
log(module=__name__, function='process', dlgid=dlgid, msg='start')
tipo_frame = form.get('TYPE', 'ERROR')
if tipo_frame == 'CTL':
from spy_raw_frame_ctl import RAW_CTL_frame
raw_clt_frame = RAW_CTL_frame(dlgid, version, payload_str)
raw_clt_frame.process()
elif tipo_frame == 'INIT':
from spy_raw_frame_init import RAW_INIT_frame
raw_init_frame = RAW_INIT_frame(dlgid, version, payload_str)
raw_init_frame.process()
elif tipo_frame == 'DATA':
from spy_raw_frame_data import RAW_DATA_frame
raw_data_frame = RAW_DATA_frame(dlgid, version, payload_str)
raw_data_frame.process()
return
def read_conf_piloto(self, dlgid):
d = dict()
log(module=__name__,
function='read_conf_piloto',
dlgid=dlgid,
msg='ERROR: can\'t exec gda_tahona !!')
return d
def process(self):
'''
Defino la logica de procesar los frames iaux0.
Por ahora solo traen la configuracion del piloto.
En el init, carque la configuracion que envia el datalogger en el frame.
Creo una estructura Piloto generica y leo de la bd los parametros que tiene
configurados dicho datalogger.
Compara las estructuras del dlg y la bd y genero la respuesta en consecuencia
Para esto hice un overload de metodo __eq__ invocado por el operador ==.
Tambien hice un overload del metodo __str__ usado por el print.
'''
log(module=__name__,
function='process',
dlgid=self.dlgid,
level='SELECT',
msg='start')
# Leo toda la configuracion desde la BD en un dict.
bd = BD(modo=Config['MODO']['modo'], dlgid=self.dlgid)
dplt = bd.read_piloto_conf()
if dplt == {}:
log(module=__name__,
function='process',
dlgid=self.dlgid,
msg='ERROR: No hay datos en la BD')
self.response = 'SRV_ERR'
self.send_response()
return
self.process_conf_piloto(dplt)
self.send_response()
return
def create_rcd(self):
if self.connected:
if not self.rh.hexists(self.dlgid, 'LINE'):
self.rh.hset(self.dlgid, 'LINE', 'NUL')
if not self.rh.hexists(self.dlgid, 'OUTPUTS'):
self.rh.hset(self.dlgid, 'OUTPUTS', '-1')
if not self.rh.hexists(self.dlgid, 'RESET'):
self.rh.hset(self.dlgid, 'RESET', 'FALSE')
if not self.rh.hexists(self.dlgid, 'POUT'):
self.rh.hset(self.dlgid, 'POUT', '-1')
if not self.rh.hexists(self.dlgid, 'PSLOT'):
self.rh.hset(self.dlgid, 'PSLOT', '-1')
if not self.rh.hexists(self.dlgid, 'MEMFORMAT'):
self.rh.hset(self.dlgid, 'MEMFORMAT', 'FALSE')
log(module=__name__,
function='create_rcd',
level='SELECT',
dlgid=self.dlgid,
msg='Redis init rcd. OK !!')
else:
log(module=__name__,
function='create_rcd',
dlgid=self.dlgid,
msg='Redis not-connected !!')
def PV_checksum_digital(self, d):
# Los canales digitales van del 0 hasta el 7 ( maximo )
# Pueden faltar algunos que no usemos por lo que no esten definidos.
# D0:D0,TIMER;D1:D1,NORMAL;
cks_str = ''
nro_digital_channels = int(self.payload_dict.get('NDCH', '0'))
for ch in range(nro_digital_channels):
ch_id = 'D{}'.format(ch) # ch_id = D1
if (ch_id, 'NAME') in d.keys(): # ( 'D1', 'NAME' ) in d.keys()
if d.get((ch_id, 'MODO'), 'NORMAL') == 'NORMAL':
# Modo NORMAL
cks_str += '%s:%s,NORMAL;' % (ch_id,
d.get((ch_id, 'NAME'), 'DX'))
else:
# Modo TIMER
cks_str += '%s:%s,TIMER;' % (ch_id,
d.get((ch_id, 'NAME'), 'DX'))
else:
cks_str += '{}:X,NORMAL;'.format(ch_id)
cks = self.PV_calcular_ckechsum(cks_str)
log(module=__name__,
function='PV_checksum_digital',
dlgid=self.dlgid,
level='SELECT',
msg='CKS_DG ({0}ch): [{1}][{2}]'.format(nro_digital_channels,
cks_str, hex(cks)))
return cks
def PV_checksum_counters(self, d):
# Los canales contadores son maximo 2
# Pueden faltar algunos que no usemos por lo que no esten definidos.
# C0:C0,1.000,100,10,0;C1:C1,1.000,100,10,0;
cks_str = ''
nro_counter_channels = int(self.payload_dict.get('NCNT', '0'))
for ch in range(nro_counter_channels):
ch_id = 'C{}'.format(ch) # ch_id = C1
if (ch_id, 'NAME') in d.keys(): # ( 'C1', 'NAME' ) in d.keys()
# La velocidad en la BD es LS o HS
cks_str += '%s:%s,%.03f,%d,%d,%s;' % (
ch_id, d.get((ch_id, 'NAME'),
'CX'), float(d.get((ch_id, 'MAGPP'), '0')),
int(d.get((ch_id, 'PERIOD'), '0')),
int(d.get(
(ch_id, 'PWIDTH'), '0')), d.get(
(ch_id, 'SPEED'), 'LS'))
else:
cks_str += '{}:X,0.100,10,100,LS;'.format(ch_id)
cks = self.PV_calcular_ckechsum(cks_str)
log(module=__name__,
function='PV_checksum_counters',
dlgid=self.dlgid,
level='SELECT',
msg='CKS_CNT ({0}ch): [{1}][{2}]'.format(nro_counter_channels,
cks_str, hex(cks)))
return cks
def PV_checksum_analog(self, d):
# Los canales analogicos van del 0 hasta el 7 ( maximo )
# Pueden faltar algunos que no usemos por lo que no esten definidos.
# A0:A0,0,20,0.000,6.000;A1:A1,0,20,0.000,6.000;A2:A2,0,20,0.000,6.000;A3:A3,0,20,0.000,6.000;A4:A4,0,20,0.000,6.000;
cks_str = ''
nro_analog_channels = int(self.payload_dict.get('NACH', '0'))
for ch in range(nro_analog_channels):
ch_id = 'A{}'.format(ch) # ch_id = A1
if (ch_id, 'NAME') in d.keys(): # ( 'A1', 'NAME' ) in d.keys()
cks_str += '%s:%s,%d,%d,%.02f,%.02f,%.02f;' % (
ch_id, d.get(
(ch_id, 'NAME'), 'AX'), int(d.get(
(ch_id, 'IMIN'), '0')),
int(d.get((ch_id, 'IMAX'),
'0')), float(d.get((ch_id, 'MMIN'), '0')),
float(d.get((ch_id, 'MMAX'),
'0')), float(d.get((ch_id, 'OFFSET'), '0')))
else:
cks_str += '{}:X,4,20,0.00,10.00,0.00;'.format(ch_id)
cks = self.PV_calcular_ckechsum(cks_str)
log(module=__name__,
function='PV_checksum_analog',
dlgid=self.dlgid,
level='SELECT',
msg='CKS_AN ({0}ch): [{1}][{2}]'.format(nro_analog_channels,
cks_str, hex(cks)))
return cks
def __init__(self, dlgid, modo='local', server='comms'):
self.modo = modo
self.dlgid = dlgid
self.bdr = ''
self.server = server
self.datasource = ''
bd = BDSPY(self.modo)
self.datasource = bd.find_data_source(self.dlgid)
if self.datasource == 'GDA':
self.bdr = BDGDA(self.modo, server)
elif self.datasource == 'GDA_TAHONA':
self.bdr = BDGDA_TAHONA(self.modo, server)
elif self.datasource == 'BDOSE_PQ':
self.bdr = BDOSE_PQ(self.modo, server)
elif self.datasource == 'BDOSE_PZ':
self.bdr = BDOSE_PZ(self.modo, server)
elif self.datasource == 'BDOSE_TQ':
self.bdr = BDOSE_TQ(self.modo, server)
elif self.datasource == 'DLGDB':
self.bdr = DLGDB(self.modo, server)
else:
self.datasource = 'DS_ERROR'
log(module=__name__,
server=server,
function='__init__',
level='INFO',
dlgid='PROC00',
msg='ERROR: DLGID={0}:DS={1} NOT implemented'.format(
dlgid, self.datasource))
return
def __init__(self, dlgid, version, dconf):
self.dlgid = dlgid
self.version = version
self.dconf = dconf
self.response = ''
level_default = 1
for i in range(9):
name = 'SMS{}'.format(i)
nivel = 'NV_SMS{}'.format(i)
nro_default = '099' + str(i) * 6
SMS_nro = dconf.get(('PPOT', name), nro_default)
if SMS_nro == '':
SMS_nro = nro_default
SMS_nivel = dconf.get(('PPOT', nivel), level_default)
if SMS_nivel == '':
SMS_nivel = level_default
level_default += 1
if level_default > 3:
level_default = 1
log(module=__name__,
function='DEBUG PPOT SMS',
dlgid=self.dlgid,
msg='name={0},nivel={1},SMS_nro={2}, SMS_nivel={3}'.format(
name, nivel, SMS_nro, SMS_nivel))
self.response += "SMS0{0}:{1},{2};".format(i, SMS_nro, SMS_nivel)
return
def __init__(self, dlgid, version, dconf ):
self.dlgid = dlgid
self.version = version
self.dconf = dconf
self.response = ''
for ch in range(6):
CH = 'CH{}'.format(ch)
self.response += ';{}:'.format(CH)
for level in range(1,4):
LVL_INF = 'A{}_INF'.format(level)
LVL_SUP = 'A{}_SUP'.format(level)
def_val_inf = d_defaults[CH][LVL_INF]
def_val_sup = d_defaults[CH][LVL_SUP]
val_inf = dconf.get((CH, LVL_INF), def_val_inf )
if val_inf == '':
val_inf = def_val_inf
val_sup = dconf.get((CH, LVL_SUP), def_val_sup )
if val_sup == '':
val_sup = def_val_sup
self.response += '{0},{1},'.format(val_inf, val_sup)
log(module=__name__, function='DEBUG PPOT LEVELS', dlgid=self.dlgid, msg='RSP={}'.format(self.response))
return
def process_line(line, bd, d_conf):
'''
Recibo una linea, la parseo y dejo los campos en un diccionario
Paso este diccionario a la BD para que la inserte.
'''
LOG.log(module=__name__,
server='process',
function='process_line',
level='SELECT',
dlgid='PROC00',
console=console,
msg='line={}'.format(line))
line = line.rstrip('\n|\r|\t')
fields = re.split(',', line)
d_data = dict()
d_data['timestamp'] = format_fecha_hora(fields[0], fields[1])
d_data['RCVDLINE'] = line
for field in fields[2:]:
mag_name, value = re.split('=', field)
d_data[mag_name] = value
#for key in d:
# LOG.log(module=__name__, server='process', function='process_line', level='SELECT', dlgid='PROC00', msg='key={0}, val={1}'.format(key,d[key]))
d = dict()
d['DATA'] = d_data
d['CONF'] = d_conf
if not bd.insert_data_line(d):
return False
return True
def reset_datasource(self, dlgid):
self.datasource = ''
log(module=__name__,
function='reset_datasource',
level='SELECT',
dlgid=dlgid,
msg='start')
def send_response(self):
log(module=__name__,
function='send_response',
dlgid=self.dlgid,
msg='RSP={0}'.format(self.response))
print('Content-type: text/html\n')
print('<html><body><h1>%s</h1></body></html>' % (self.response))
def clear_commited_conf(self):
'''
Reseteo el valor de commited_conf a 0
'''
log(module=__name__, function='clear_commited_conf', level='SELECT', dlgid=self.dlgid, msg='DS={}'.format(self.datasource))
self.bdr.clear_commited_conf(self.dlgid)
return
def PV_checksum_base(self, d):
timerdial = d.get(('BASE', 'TDIAL'), '0')
timerpoll = d.get(('BASE', 'TPOLL'), '0')
timepwrsensor = d.get(('BASE', 'TIMEPWRSENSOR'), 0)
pwrs_modo = d.get(('BASE', 'PWRS_MODO'), '0')
if pwrs_modo == '0':
pwrs_modo = 'OFF'
elif pwrs_modo == '1':
pwrs_modo = 'ON'
pwrs_start = d.get(('BASE', 'PWRS_HHMM1'), '0000')
if int(pwrs_start) < 1000:
pwrs_start = '0' + pwrs_start
pwrs_end = d.get(('BASE', 'PWRS_HHMM2'), '0000')
if int(pwrs_end) < 1000:
pwrs_end = '0' + pwrs_end
# Calculo el checksum.
# Debo hacerlo igual a como lo hago en el datalogger.
cks_str = '{0},{1},{2},{3},{4},{5}'.format(timerdial, timerpoll,
timepwrsensor, pwrs_modo,
pwrs_start, pwrs_end)
cks = self.PV_calcular_ckechsum(cks_str)
log(module=__name__,
function='PV_checksum_base',
dlgid=self.dlgid,
level='SELECT',
msg='CKS_BASE: [{0}][{1}]'.format(cks_str, hex(cks)))
return cks
def init_from_qs(self, ch_id):
'''
qs es el string parseado tipo D0=DIN,250
Primero vemos que no sea vacio.
Luego lo parseamos y rellenamos los campos del self.
'''
form = cgi.FieldStorage()
field = form.getfirst(
ch_id, 'X,0') # Los canales que no estan los asumo apagados 'X'
if field is not None:
try:
self.name, self.tpoll = re.split('=|,', field)
self.tpoll = int(self.tpoll)
except Exception as err_var:
log(module=__name__,
function='init_from_qs',
level='INFO',
dlgid=self.dlgid,
msg='ERROR: {0}_unpack {1}'.format(ch_id, field))
log(module=__name__,
function='init_from_qs',
dlgid=self.dlgid,
msg='ERROR: EXCEPTION {}'.format(err_var))
self.name = 'X'
self.tpoll = 0
return
def get_response_string(self, other):
'''
Genero el string que deberia mandarse al datalogger con la configuracion
en la BD del piloto para ese dlgid
El objeto sobre el cual se llama debe ser la referencia de la BD.
El 'other' es el objeto con los datos del datalogger
'''
response = ''
if self.tpoll != other.tpoll:
response += 'TPOLL=%s:' % self.tpoll
if self.tdial != other.tdial:
response += 'TDIAL=%s:' % self.tdial
if (self.pwrs_modo != other.pwrs_modo
or self.pwrs_start != other.pwrs_start
or self.pwrs_end != other.pwrs_end):
response += 'PWRS=%s,%s,%s:' % (self.pwrs_modo, self.pwrs_start,
self.pwrs_end)
if self.dist != other.dist:
response += 'DIST=%s:' % self.dist
log(module=__name__,
function='get_response_string',
level='SELECT',
dlgid=self.dlgid,
msg='confbase_RSP: {}'.format(response))
return (response)
def get_response_string(self, other ):
'''
Genero el string que deberia mandarse al datalogger con la configuracion
de los canales analogicos a reconfigurarse
El objeto ( self) sobre el cual se llama debe ser la referencia de la BD.
El other es el objeto con los datos del datalogger
'''
response = ''
if self.D0 != other.D0:
response += self.D0.get_response_string()
if self.D1 != other.D1:
response += self.D1.get_response_string()
if self.D2 != other.D2:
response += self.D2.get_response_string()
if self.D3 != other.D3:
response += self.D3.get_response_string()
if self.D4 != other.D4:
response += self.D4.get_response_string()
if self.D5 != other.D5:
response += self.D5.get_response_string()
if self.D6 != other.D6:
response += self.D6.get_response_string()
if self.D7 != other.D7:
response += self.D7.get_response_string()
log(module=__name__, function='get_response_string', level='SELECT', dlgid=self.dlgid, msg='confbase_RSP: {}'.format(response))
return(response)
def process_callbacks(self):
#log(module=__name__, function='process_callbacks', dlgid=self.dlgid, level='SELECT',msg='CALLBACK start')
# Aqui debo invocar al perl con el parametro self.dlgid
# Leo los callbacks.
dict_cb = dict()
for key, callback_file in Config['CALLBACKS'].items():
cb_dlgid = key.upper()
#log(module=__name__, function='process_callbacks', dlgid=self.dlgid, level='SELECT', msg='CBK: dlgid {0}:script {1}'.format(cb_dlgid, callback_file))
dict_cb[cb_dlgid] = callback_file
if self.dlgid in dict_cb:
log(module=__name__,
function='process_callbacks',
dlgid=self.dlgid,
level='SELECT',
msg='CALLBACK start')
newpid = os.fork()
if newpid == 0:
# Child
PATH = Config['CALLBACKS_PATH']['cbk_path']
PROGRAM = dict_cb[self.dlgid]
CBK = os.path.join(PATH, PROGRAM)
os.execl(CBK, PROGRAM, self.dlgid)
exit(0)
def init_from_qs(self, ch_id):
'''
qs es el string parseado tipo C0=CNT0,0.1,10,100,HS
Primero vemos que no sea vacio.
Luego lo parseamos y rellenamos los campos del self.
C0,0.10,0.2,100,LS
'''
form = cgi.FieldStorage()
field = form.getfirst(
ch_id,
'X,0,0,0,LS') # Los canales que no estan los asumo apagados 'X'
if field is not None:
try:
self.name, self.magpp, self.pwidth, self.period, self.speed, *r = re.split(
'=|,', field)
self.magpp = float(self.magpp)
self.pwidth = int(self.pwidth)
self.period = int(self.period)
except Exception as err_var:
log(module=__name__,
function='init_from_qs',
level='INFO',
dlgid=self.dlgid,
msg='ERROR: {0}_unpack {1}'.format(ch_id, field))
log(module=__name__,
function='init_from_qs',
dlgid=self.dlgid,
msg='EXCEPTION {}'.format(err_var))
return
def __init__ (self, dlgid, modo = 'local', server='comms'):
'''
El objeto que creo es un puntero a la BD generico
Luego de find_data_source, puedo saber en que BD real esta definido el datalooger.
Este lo dejo en el parametro bdr que va a apuntar a la clase de la base de datos
donde realmente esta definido el datalogger.
Las consultas se mapean a metodos de esta clase.
'''
self.modo = modo
self.dlgid = dlgid
self.bdr = ''
self.server = server
self.datasource = ''
log(module=__name__, function='__init__', dlgid=self.dlgid, msg='start')
bd = BDSPY(self.modo)
self.datasource = bd.find_data_source(self.dlgid)
if self.datasource == 'GDA':
self.bdr = BDGDA(self.modo, server)
elif self.datasource == 'GDA_TAHONA':
self.bdr = BDGDA_TAHONA(self.modo, server)
elif self.datasource == 'BDOSE_PQ':
self.bdr = BDOSE_PQ(self.modo, server)
elif self.datasource == 'BDOSE_PZ':
self.bdr = BDOSE_PZ(self.modo, server)
elif self.datasource == 'BDOSE_TQ':
self.bdr = BDOSE_TQ(self.modo, server)
elif self.datasource == 'DLGDB':
self.bdr = DLGDB(self.modo, server)
else:
self.datasource = 'DS_ERROR'
log(module=__name__, server=server, function='__init__', level='INFO', dlgid='PROC00', msg='ERROR: DLGID={0}:DS={1} NOT implemented'.format(dlgid, self.datasource))
return
def read_piloto_conf(self, dlgid):
'''
Lee de la base GDA la configuracion de los pilotos para el datalogger dado.
Retorna un diccionario con los datos.
La BD devuelve
+--------+-----------+-------+----------+
| canal | parametro | value | param_id |
+--------+-----------+-------+----------+
| PILOTO | HHMM_0 | 230 | 1107 |
| PILOTO | HHMM_2 | 650 | 1107 |
| PILOTO | POUT_4 | 1.3 | 1107 |
| PILOTO | POUT_1 | 2.4 | 1107 |
| PILOTO | POUT_2 | 1.8 | 1107 |
| PILOTO | POUT_3 | 1.6 | 1107 |
| PILOTO | HHMM_3 | 1040 | 1107 |
| PILOTO | PSTEPS | 6 | 1107 |
| PILOTO | HHMM_1 | 430 | 1107 |
| PILOTO | POUT_0 | 1.2 | 1107 |
| PILOTO | PBAND | 0.2 | 1107 |
| PILOTO | HHMM_4 | 1750 | 1107 |
+--------+-----------+-------+----------+
Los datos se ponene un un diccionario con key=parametro y este se retorna
'''
log(module=__name__, server=self.server, function='read_piloto_conf', dlgid=dlgid, level='SELECT', msg='start')
if not self.connect():
log(module=__name__, server=self.server, function='read_piloto_conf', dlgid=dlgid, msg='ERROR: can\'t connect gda !!')
return False
sql = """SELECT spx_unidades_configuracion.nombre as 'canal',
spx_configuracion_parametros.parametro, spx_configuracion_parametros.value,
spx_configuracion_parametros.configuracion_id as 'param_id'
FROM spx_unidades,spx_unidades_configuracion, spx_tipo_configuracion, spx_configuracion_parametros
WHERE spx_unidades.id = spx_unidades_configuracion.dlgid_id
AND spx_unidades_configuracion.tipo_configuracion_id = spx_tipo_configuracion.id
AND spx_configuracion_parametros.configuracion_id = spx_unidades_configuracion.id
AND spx_unidades_configuracion.nombre = 'PILOTO' AND spx_unidades.dlgid = '{}'""".format(dlgid)
try:
query = text(sql)
except Exception as err_var:
log(module=__name__, server=self.server, function='read_piloto_conf', dlgid=dlgid, msg='ERROR: SQLQUERY: {}'.format(sql))
log(module=__name__, server=self.server, function='read_piloto_conf', dlgid=dlgid, msg='ERROR: EXCEPTION {}'.format(err_var))
return False
d = dict()
try:
rp = self.conn.execute(query)
except Exception as err_var:
log(module=__name__, server=self.server, function='read_piloto_conf', dlgid=dlgid,msg='ERROR: GDA exec EXCEPTION {}'.format(err_var))
return False
results = rp.fetchall()
d = dict()
for row in results:
tag, pname, value, pid = row
d[pname] = value
return d
def log(self, tag=''):
log(module=__name__,
function='log',
level='SELECT',
dlgid=self.dlgid,
msg='{0} id={1}: name={2} tpoll={3}'.format(
tag, self.id, self.name, self.tpoll))
return
def __init__(self, dlgid, version, payload_dict):
# payload_dict={TYPE:SCAN;UID:304632333433180f000500}
self.dlgid = dlgid
self.version = version
self.payload_dict = payload_dict
self.response_pload = ''
log(module=__name__, function='__init__', dlgid=self.dlgid, msg='start')
return
def send_response(self):
pload = 'CLASS:GLOBAL;{}'.format(self.response_pload)
u_send_response('INIT', pload)
log(module=__name__,
function='send_response',
dlgid=self.dlgid,
msg='PLOAD={0}'.format(pload))
return
def find_data_source(self, dlgid):
"""
Determina en que base de datos (GDA/TAHONA/bd_ose) esta definido el dlg
Retorna True/False
En la bd_ose tenemos 3 grupos de tablas: PZ(pozos), TQ(tanques), PQ(presiones y caudales)
En esta instancia si el datasource es bd_ose, determinamos a que grupo pertenece de modo
de ahorrarle trabajo luego a las funciones de lectura/escritura de la BD.
Retorna: datasource o None
"""
# Si ya tengo el datasource no tengo que consultar a la BD.
if self.datasource == 'GDA' or self.datasource == 'bd_ose':
return self.datasource
if not self.connect():
log(module=__name__,
server=self.server,
function='find_data_source',
dlgid=dlgid,
msg='ERROR: can\'t connect bdspy !!')
return
query = text(
"SELECT datasource FROM spy_equipo WHERE dlgid = '{}'".format(
dlgid))
try:
rp = self.conn.execute(query)
except Exception as err_var:
log(module=__name__,
server=self.server,
function='find_data_source',
dlgid=dlgid,
msg='ERROR: can\'t exec bdspy !!')
log(module=__name__,
server=self.server,
function='find_data_source',
dlgid=dlgid,
msg='ERROR: EXCEPTION {}'.format(err_var))
return
results = rp.fetchone()
if results is None:
log(module=__name__,
server=self.server,
function='find_data_source',
dlgid=dlgid,
msg='ERROR: DS=None')
return
self.datasource = results[0]
log(module=__name__,
server=self.server,
function='find_data_source',
dlgid=dlgid,
msg='DS={}'.format(self.datasource))
return self.datasource
def __init__(self, dlgid, version, payload):
self.dlgid = dlgid
self.version = version
self.payload_str = payload
log(module=__name__,
function='__init__',
dlgid=self.dlgid,
msg='start')
return
def process(self):
'''
El procesamiento consiste en logear el string de respuesta y enviarlo al datalogger.
'''
log(module=__name__, function='get_response_string', level='SELECT', dlgid=self.dlgid, msg='confPPotLevels_RSP: ({})'.format(self.response))
pload = 'CLASS:APP_C{}'.format(self.response )
u_send_response('INIT', pload)
log(module=__name__, function='send_response', dlgid=self.dlgid, msg='PLOAD={0}'.format(pload))
return
def read_piloto_conf(self):
log(module=__name__,
function='read_piloto_conf',
level='SELECT',
dlgid=self.dlgid,
msg='start')
# En ppio no se en que BD esta definido el datalogger. Debo leer su datasource
d = self.bdr.read_piloto_conf(self.dlgid)
return d
def process_commited_conf(self):
log(module=__name__,
function='process_commited_conf',
level='SELECT',
dlgid=self.dlgid,
msg='DS={}'.format(self.datasource))
cc = self.bdr.process_commited_conf(self.dlgid)
return cc
