def _handle_msg(self, time, ttlop, ttl, tsop, key, op, value):
if key.startswith('watchdog/'):
self._handle_control_msg(key, cache_load(value), time,
op != OP_TELL)
return
key = key[len(self._prefix):].replace('/', '_').lower()
# do we need the key for conditions?
if key not in self._keymap:
return
expired = op == OP_TELLOLD or not value
value = None if expired else cache_load(value)
if not expired:
self._keydict[key] = value
else:
self._keydict.pop(key, None)
time = float(time)
if self._process_updates:
self._process_key(time, key, value)
def _handle_msg(self, time, ttlop, ttl, tsop, key, op, value):
if op != OP_TELL or not key.startswith(self._prefix):
return
key = key[len(self._prefix):]
time = time and float(time)
# self.log.info('got %s=%r', key, value)
if key in self._handler.handlers:
try:
value = cache_load(value)
self._handler.handlers[key](time, value)
except Exception:
self.log.exception('Error in handler for: %s=%r', key, value)
def _handle_msg(self, time, ttlop, ttl, tsop, key, op, value):
if op not in (OP_TELL, OP_TELLOLD):
return
if not key.startswith(self._prefix):
for cb in self._prefixcallbacks:
if key.startswith(cb):
if value is not None:
value = cache_load(value)
time = time and float(time)
try:
self._prefixcallbacks[cb](key, value, time,
op != OP_TELL)
except Exception:
self.log.warning('error in cache callback', exc=1)
return
key = key[len(self._prefix):]
time = time and float(time)
# ignore outdated 'updates'
db_time = self._db.get(key, (0, 0))[1]
if db_time > time:
self.log.debug('ignoring outdated update for %s: %gs too old', key,
db_time - time)
return
self._propagate((time, key, op, value))
# self.log.debug('got %s=%s', key, value)
if not value or op == OP_TELLOLD:
with self._dblock:
self._db.pop(key, None)
else:
value = cache_load(value)
with self._dblock:
self._db[key] = (value, time)
if self._do_callbacks:
if key in self._callbacks:
self._call_callbacks(key, value, time)
if key.endswith('/value') and session.experiment:
session.experiment.data.cacheCallback(key, value, time)
def _processQueue(self):
while True:
name, value, status, timestamp = self._queue.get()
try:
# Convert value from string to correct type
value = cache_load(value)
if not isinstance(value, str):
# Policy decision: don't send strings via f142
buffer = to_f142(name, value, status, timestamp)
self._send_to_kafka(buffer)
except Exception as error:
self.log.error('Could not forward data: %s', error)
self._queue.task_done()
def history(self, dev, key, fromtime, totime):
"""History query: opens a separate connection since it is otherwise not
possible to determine which response lines belong to it.
"""
if dev:
key = ('%s/%s' % (dev, key)).lower()
tosend = '%r-%r@%s%s%s\n###?\n' % (fromtime, totime, self._prefix, key,
OP_ASK)
ret = []
for msgmatch in self._single_request(tosend, b'###!\n', sync=False):
# process data
time, value = msgmatch.group('time'), msgmatch.group('value')
if time is None:
break # it's the '###' value
if value:
ret.append((float(time), cache_load(value)))
return ret
def get_explicit(self, dev, key, default=None):
"""Get a value from the cache server, bypassing the local cache. This
is needed if the current update time and ttl is required.
"""
if dev:
key = ('%s/%s' % (dev, key)).lower()
tosend = '@%s%s%s\n' % (self._prefix, key, OP_ASK)
for msgmatch in self._single_request(tosend):
if msgmatch.group('tsop') is None:
raise CacheError('Cache did not send timestamp info')
time, ttl, value = msgmatch.group('time'), msgmatch.group('ttl'), \
msgmatch.group('value')
# self.log.debug('get_explicit: %.2f %.2f %r', time, ttl, value)
if value:
return (time and float(time), ttl
and float(ttl), cache_load(value))
return (time and float(time), ttl and float(ttl), default)
return (None, None, default) # shouldn't happen
def getValue(self):
return cache_load(self.text())
def on_client_cache(self, data):
(time, key, op, value) = data
if '/' not in key:
return
ldevname, subkey = key.rsplit('/', 1)
if ldevname not in self._devinfo:
return
if ldevname in self._control_dialogs:
self._control_dialogs[ldevname].on_cache(subkey, value)
devitem = self._devitems[ldevname]
devinfo = self._devinfo[ldevname]
if subkey == 'value':
if time < devinfo.valtime:
return
if not value:
fvalue = ''
else:
fvalue = cache_load(value)
if isinstance(fvalue, list):
fvalue = tuple(fvalue)
devinfo.value = fvalue
devinfo.expired = op != OP_TELL
devinfo.valtime = time
fmted = devinfo.fmtValUnit()
devitem.setText(1, fmted)
if ldevname in self._control_dialogs:
self._control_dialogs[ldevname].valuelabel.setText(fmted)
devitem.setForeground(1, valueBrush[devinfo.expired,
devinfo.fixed])
if not devitem.parent().isExpanded():
if ldevname == devitem.parent().representative:
devitem.parent().setText(1, fmted)
elif subkey == 'status':
if time < devinfo.stattime:
return
if not value:
status = (UNKNOWN, '?')
else:
status = cache_load(value)
devinfo.status = status
devinfo.stattime = time
devitem.setText(2, str(status[1]))
if status[0] not in self.statusIcon:
# old or wrong status constant
return
if self.useicons:
devitem.setIcon(0, self.statusIcon[status[0]])
devitem.setForeground(2, foregroundBrush[status[0]])
devitem.setBackground(2, backgroundBrush[status[0]])
else:
devitem.setForeground(0, foregroundBrush[BUSY])
devitem.setBackground(0, backgroundBrush[status[0]])
if not devitem.parent().isExpanded():
item = devitem.parent()
item.setBackground(
0, backgroundBrush[self._getHighestStatus(item)])
else:
devitem.parent().setBackground(0, backgroundBrush[OK])
if ldevname in self._control_dialogs:
dlg = self._control_dialogs[ldevname]
dlg.statuslabel.setText(status[1])
dlg.statusimage.setPixmap(self.statusIcon[status[0]].pixmap(
16, 16))
setForegroundBrush(dlg.statuslabel, foregroundBrush[status[0]])
setBackgroundBrush(dlg.statuslabel, backgroundBrush[status[0]])
elif subkey == 'fmtstr':
if not value:
return
devinfo.fmtstr = cache_load(value)
devitem.setText(1, devinfo.fmtValUnit())
elif subkey == 'unit':
if not value:
value = "''"
devinfo.unit = cache_load(value)
devitem.setText(1, devinfo.fmtValUnit())
elif subkey == 'fixed':
if not value:
value = "''"
devinfo.fixed = bool(cache_load(value))
devitem.setForeground(1, valueBrush[devinfo.expired,
devinfo.fixed])
if ldevname in self._control_dialogs:
dlg = self._control_dialogs[ldevname]
if dlg.moveBtn:
dlg.moveBtn.setEnabled(not devinfo.fixed)
dlg.moveBtn.setText(devinfo.fixed and '(fixed)' or 'Move')
elif subkey == 'userlimits':
if not value:
return
value = cache_load(value)
if ldevname in self._control_dialogs:
dlg = self._control_dialogs[ldevname]
dlg.limitMin.setText(str(value[0]))
dlg.limitMax.setText(str(value[1]))
elif subkey == 'classes':
if not value:
value = "[]"
devinfo.classes = set(cache_load(value))
elif subkey == 'alias':
if not value:
return
if ldevname in self._control_dialogs:
dlg = self._control_dialogs[ldevname]
dlg._reinit()
elif subkey == 'description':
devitem.setToolTip(0, cache_load(value or "''"))
if subkey in self.param_display.get(ldevname, ()):
if not devinfo.params:
devinfo.params = self.client.getDeviceParamInfo(devinfo.name)
value = devinfo.fmtParam(subkey, cache_load(value))
if subkey not in self._devparamitems.setdefault(ldevname, {}):
devitem = self._devitems[ldevname]
self._devparamitems[ldevname][subkey] = \
QTreeWidgetItem(devitem, [subkey, value, ''], PARAM_TYPE)
devitem.setExpanded(True)
else:
self._devparamitems[ldevname][subkey].setText(1, value)
def _propagate(self, args):
time, key, op, value = args
if op == OP_TELL and key in self._callbacks and value:
self._call_callbacks(key, cache_load(value), time)
def on_client_cache(self, data):
(_, key, _, value) = data
if key == 'opmode/value' and value:
self._curmode = cache_load(value)
def on_client_cache(self, data):
_time, key, _op, value = data
if key == 'exp/action':
self.curstatus.setText(cache_load(value) or 'Idle')
def on_client_cache(self, data):
_time, key, _op, value = data
if key == 'psd_channel/_foildata':
self._data = cache_load(value)
self.do_update()
