class _ScheduleThread(threading.Thread):
r"""
"""
def __init__(self, schedule, schedule_interval=1):
threading.Thread.__init__(self, name="ScheduleThread")
self.spine = None
self.terminate = False
self.schedule_interval = schedule_interval
self.schedule = schedule
self.daemon = True
def run(self):
while not self.terminate:
if not self.spine:
self.spine = Spine()
if self.spine:
self.spine.register_command_handler(
"stopThreads", self._stop_command)
else:
self.schedule.run_pending()
time.sleep(self.schedule_interval)
def _stop_command(self):
if not self.terminate:
self.terminate = True
def __init__(self, command, protocol):
self.protocol = protocol
self.command = command
spine = Spine()
#print("rc", command)
spine.register_command_handler(command,
self.on_command,
injected="socketSpine")
class _SensorThread(KerviThread):
r"""
SensorThread is the base class that polls sensors.
Add one or more sensors and set polling interval.
:param sensors:
Id of the sensor.
This id is used in other components to reference this sesnor.
:type sensors: ``str``
:param reading_interval:
Polling interval in seconds between
:type reading_interval: ``float``
"""
def __init__(self, sensors, reading_interval=1):
KerviThread.__init__(self)
self.spine = Spine()
if self.spine:
self.spine.register_command_handler("startThreads",
self._start_command)
self.spine.register_command_handler("stopThreads",
self._stop_command)
self.alive = False
self.reading_interval = reading_interval
if hasattr(sensors, "__len__"):
self.sensors = sensors
else:
self.sensors = [sensors]
def new_sensor_reading(self, value, sensor_idx=0):
self.sensors[sensor_idx]._new_sensor_reading(value)
def _step(self):
for sensor in self.sensors:
sensor._read_sensor()
self.sensor_step()
time.sleep(self.reading_interval)
def sensor_step(self):
pass
def _start_command(self):
if not self.alive:
self.alive = True
KerviThread.start(self)
def _stop_command(self):
if self.alive:
self.alive = False
self.stop()
class ModuleThread(KerviThread):
def __init__(self):
KerviThread.__init__(self)
self.spine = Spine()
self.spine.register_command_handler("startThreads", self._startCommand)
def _step(self):
self.moduleStep()
def _startCommand(self):
if not self.isAlive():
super(KerviThread, self).start()
def _stopCommand(self):
self.stop()
class ChannelPollingThread(KerviThread):
def __init__(self, channel, device, callback, polling_time=.1):
KerviThread.__init__(self)
self._callback = callback
self._channel = channel
self._device = device
self._value = None
self._polling_time = polling_time
self.alive = False
self.spine = Spine()
if self.spine:
self.spine.register_command_handler("startThreads",
self._start_command)
self.spine.register_command_handler("stopThreads",
self._stop_command)
def _step(self):
"""Private method do not call it directly or override it."""
try:
new_value = self._device.get(self._channel)
if new_value != self._value:
self._callback(new_value)
self._value = new_value
time.sleep(self._polling_time)
except:
self.spine.log.exception("_PollingThread")
def _start_command(self):
if not self.alive:
self.alive = True
KerviThread.start(self)
def _stop_command(self):
if self.alive:
self.alive = False
self.stop()
class StorageManager(Controller):
def __init__(self, log_queue):
Controller.__init__(self, "storage_manager", "Storage manager")
self._spine = Spine()
self._spine.register_event_handler("valueChanged", self._store_value)
self._spine.register_query_handler("getValueData",
self._get_value_data)
self._spine.register_command_handler("storeSetting",
self._store_setting)
self._spine.register_query_handler("retrieveSetting",
self._retrieve_setting)
self._spine.register_query_handler("getMessageItems",
self._get_messages)
self._spine.register_event_handler("newMessage", self._store_message)
#SPINE.register_command_handler("createCronJob", create_cron_job)
#SPINE.register_command_handler("deleteCronJob", delete_cron_job)
#SPINE.register_query_handler("queryCronJob", query_cron_job)
self._plugin_manager = None
self._plugin_manager = PluginManager(Configuration,
"storage", [StoragePlugin],
log_queue=log_queue)
self._plugin_manager.load_managed_plugins()
def _store_value(self, value_id, value, persist=False):
for plugin in self._plugin_manager.plugins:
try:
if persist and plugin.storage_type == "persisted":
plugin.store_value(value_id, value, persist)
elif not persist and not plugin.storage_type == "persisted":
plugin.store_value(value_id, value, persist)
except NotImplementedError:
pass
def _get_value_data(self, value, date_from=None, date_to=None, limit=60):
for plugin in self._plugin_manager.plugins:
try:
plugin.get_value_data(value, date_from, date_to, limit)
except NotImplementedError:
pass
def _store_setting(self, group, name, value):
for plugin in self._plugin_manager.plugins:
try:
if plugin.storage_type == "persisted":
plugin.store_setting(group, name, value)
except NotImplementedError:
pass
def _retrieve_setting(self, group, name):
for plugin in self._plugin_manager.plugins:
try:
if plugin.storage_type == "persisted":
return plugin.retrieve_setting(group, name)
except NotImplementedError:
pass
def _store_message(self, source_id, item):
for plugin in self._plugin_manager.plugins:
try:
plugin.store_message(source_id, item)
except NotImplementedError:
pass
def _get_messages(self, page, page_size, filters=None):
for plugin in self._plugin_manager.plugins:
try:
plugin.get_messages(self, page, page_size, filters)
except NotImplementedError:
pass