class _WebEventHandler(object):
def __init__(self, event, id_event, protocol):
self.protocol = protocol
self.event = event
self.id_event = id_event
self.spine = Spine()
#print("re", event, id_event)
self.spine.register_event_handler(event,
self.on_event,
id_event,
injected="socketSpine")
def on_event(self, id_event, *args, **kwargs):
injected = kwargs.get("injected", "")
groups = kwargs.get("groups", None)
process_id = kwargs.get("process_id", None)
self.spine.log.debug("WS relay event:{0} injected:{1}", self.event,
injected)
authorized = True
if self.protocol.user != None and self.protocol.user[
"groups"] != None and groups != None and len(groups) > 0:
for group in groups:
if group in self.protocol.user["groups"]:
break
else:
authorized = False
if authorized and self.protocol.authenticated and not injected == "socketSpine":
cmd = {
"messageType": "event",
"event": self.event,
"id": id_event,
"args": args
}
jsonres = json.dumps(cmd, cls=_ObjectEncoder,
ensure_ascii=False).encode('utf8')
#if self.event=="userLogMessage":
# print("wum", id_event, process_id, injected, jsonres)
self.protocol.sendMessage(jsonres, False)
class _WebEventHandler(object):
def __init__(self, event, id_event, protocol):
self.protocol = protocol
self.event = event
self.id_event = id_event
self.spine = Spine()
self.spine.register_event_handler(event, self.on_event, id_event, injected="socketSpine")
self._eps_counter = 0
self._eps_start_time = time.time()
self._eps = 0
def on_event(self, id_event, *args, **kwargs):
injected = kwargs.get("injected", "")
groups = kwargs.get("groups", None)
#process_id = kwargs.get("process_id", None)
#self.spine.log.debug("WS relay event:{0} injected:{1}", self.event, injected)
self._eps_counter += 1
now = time.time()
seconds = now - self._eps_start_time
if (seconds) > 1 :
self._eps = self._eps_counter / seconds
self._eps_counter = 0
self._eps_start_time = now
authorized = True
if self.protocol.user != None and self.protocol.user["groups"] != None and groups != None and len(groups) > 0:
for group in groups:
if group in self.protocol.user["groups"]:
break
else:
authorized = False
if authorized and self.protocol.authenticated and not injected == "socketSpine":
cmd = {"messageType":"event", "event":self.event, "id":id_event, "args":args, "eps": self._eps, "ts": now}
jsonres = json.dumps(cmd, cls=_ObjectEncoder, ensure_ascii=False).encode('utf8')
self.protocol.broadcast_message(self.protocol, jsonres)
class _LinkedAction(object):
def __init__(self, action_id):
self._action_id = action_id
self.spine = Spine()
self.spine.register_event_handler("actionDone", self._action_done,
action_id)
self.spine.register_event_handler("actionStarted",
self._action_started, action_id)
self.spine.register_query_handler("getComponentRoutes",
self._get_component_bus_routes)
self._state = ACTION_STOPPED
self._action_event = None
self._action_lock = threading.Lock()
self._process_locked = False
self._is_running = False
self._last_result = None
self._observers = []
self._spine_observers = {}
def _get_component_bus_routes(self):
return {
"id":
None,
"routes": [{
"id": self._action_id,
"direction": "in",
"topic_type": "event",
"topic": "actionStarted"
}, {
"id": self._action_id,
"direction": "in",
"topic_type": "event",
"topic": "actionDone"
}, {
"id": self._action_id,
"direction": "out",
"topic_type": "command",
"topic": "kervi_action_" + self._action_id
}],
}
def _action_done(self, id, state, result):
if self._state == ACTION_RUNNING:
self._state = state
self._last_result = result
if self._action_event:
self._action_event.set()
if self._process_locked:
self._process_locked = False
self._action_lock.release()
self._is_running = False
def _action_started(self, id):
self._state = ACTION_RUNNING
self._last_result = None
self._is_running = True
if self._action_lock.acquire(False):
self._process_locked = True
def run_every(self, interval=1):
"""
Schedule an action to run periodically.
:param interval: A quantity of a certain time unit
"""
job = ActionJob(interval, default_scheduler, self)
return job
@property
def is_running(self):
return self._is_running
@property
def state(self):
"""Returns the running state of the action."""
return self._state
def interrupt(self, *args, **kwargs):
self.spine.send_command("kervi_action_interrupt_" + self._action_id,
*args, **kwargs)
def execute(self, *args, **kwargs):
"""Executes the action."""
timeout = kwargs.pop("timeout", -1)
run_async = kwargs.pop("run_async", False)
self._is_running = True
result = None
if self._action_lock.acquire(False):
self._state = ACTION_PENDING
self._action_event = threading.Event()
self.spine.send_command("kervi_action_" + self._action_id, *args,
**kwargs)
if not run_async:
if self._action_event.wait(timeout):
self._state = ACTION_FAILED
raise TimeoutError("Timeout in call to action: " +
self._action_id)
self._action_event = None
result = self._last_result
else:
self._action_lock.release()
else:
if not self._action_lock.acquire(True, timeout):
return None
self._action_lock.release()
return result
def __call__(self, *args, **kwargs):
self.execute(*args, **kwargs)
def link_to(self, source, **kwargs):
from kervi.values.kervi_value import KerviValue
if isinstance(source, KerviValue):
source.add_observer(self)
self._spine_observers[source.value_id] = kwargs
elif isinstance(source, str):
self.spine.register_event_handler("valueChanged",
self._link_changed_event, source)
self._spine_observers[source] = kwargs
def kervi_value_changed(self, source, value):
self._link_changed_event(source.value_id, {
"id": source.value_id,
"value": source.value
}, value)
def _link_changed_event(self, id, source, old_value):
if source["id"] in self._spine_observers.keys():
kwargs = self._spine_observers[source["id"]]
value = source["value"]
self._handle_link_event(value, **kwargs)
def _handle_link_event(self, value, **kwargs):
pass_value = kwargs.pop("pass_value", False)
trigger_value = kwargs.pop("trigger_value", True)
trigger_interrupt_value = kwargs.pop("trigger_interrupt_value", False)
action_parameters = kwargs.pop("action_parameters", [])
interrupt_parameters = kwargs.pop("interrupt_parameters", [])
if pass_value:
action_parameters = [value] + action_parameters
if isinstance(trigger_value, types.LambdaType) and trigger_value(
value) and not self.is_running:
self.execute(*action_parameters, run_async=True)
if isinstance(trigger_interrupt_value, types.LambdaType
) and trigger_interrupt_value(value) and self.is_running:
self.interrupt(*interrupt_parameters)
elif trigger_value == value and not self.is_running:
self.execute(*action_parameters, run_async=True)
elif trigger_interrupt_value == value and self.is_running:
self.interrupt(*interrupt_parameters)
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