135 lines
5.0 KiB
Python
135 lines
5.0 KiB
Python
|
|
import sys
|
|
import threading
|
|
|
|
from multiprocessing import Pipe
|
|
from random import randrange
|
|
from typing import Any, Union
|
|
|
|
from core.correctness.vars import DEBUG_WARNING, DEBUG_INFO, EVENT_TYPE, \
|
|
VALID_CHANNELS
|
|
from core.correctness.validation import setup_debugging, check_type, \
|
|
valid_list
|
|
from core.functionality import print_debug, wait
|
|
from core.meow import BaseHandler, BaseMonitor
|
|
|
|
|
|
class MeowRunner:
|
|
monitors:list[BaseMonitor]
|
|
handlers:dict[str:BaseHandler]
|
|
from_monitor: list[VALID_CHANNELS]
|
|
def __init__(self, monitors:Union[BaseMonitor,list[BaseMonitor]],
|
|
handlers:Union[BaseHandler,list[BaseHandler]],
|
|
print:Any=sys.stdout, logging:int=0) -> None:
|
|
self._is_valid_handlers(handlers)
|
|
if not type(handlers) == list:
|
|
handlers = [handlers]
|
|
self.handlers = {}
|
|
for handler in handlers:
|
|
handler_events = handler.valid_event_types()
|
|
for event in handler_events:
|
|
if event in self.handlers.keys():
|
|
self.handlers[event].append(handler)
|
|
else:
|
|
self.handlers[event] = [handler]
|
|
|
|
self._is_valid_monitors(monitors)
|
|
if not type(monitors) == list:
|
|
monitors = [monitors]
|
|
self.monitors = monitors
|
|
self.from_monitors = []
|
|
for monitor in self.monitors:
|
|
monitor_to_runner_reader, monitor_to_runner_writer = Pipe()
|
|
monitor.to_runner = monitor_to_runner_writer
|
|
self.from_monitors.append(monitor_to_runner_reader)
|
|
|
|
self._stop_pipe = Pipe()
|
|
self._worker = None
|
|
self._print_target, self.debug_level = setup_debugging(print, logging)
|
|
|
|
def run(self)->None:
|
|
all_inputs = self.from_monitors + [self._stop_pipe[0]]
|
|
while True:
|
|
ready = wait(all_inputs)
|
|
|
|
if self._stop_pipe[0] in ready:
|
|
return
|
|
else:
|
|
for from_monitor in self.from_monitors:
|
|
if from_monitor in ready:
|
|
message = from_monitor.recv()
|
|
event = message
|
|
if not self.handlers[event[EVENT_TYPE]]:
|
|
print_debug(self._print_target, self.debug_level,
|
|
"Could not process event as no relevent "
|
|
f"handler for '{EVENT_TYPE}'", DEBUG_INFO)
|
|
return
|
|
if len(self.handlers[event[EVENT_TYPE]]) == 1:
|
|
self.handlers[event[EVENT_TYPE]][0].handle(event)
|
|
else:
|
|
self.handlers[event[EVENT_TYPE]][
|
|
randrange(len(self.handlers[event[EVENT_TYPE]]))
|
|
].handle(event)
|
|
|
|
def start(self)->None:
|
|
for monitor in self.monitors:
|
|
monitor.start()
|
|
startable = []
|
|
for handler_list in self.handlers.values():
|
|
for handler in handler_list:
|
|
if hasattr(handler, "start") and handler not in startable:
|
|
startable.append()
|
|
for handler in startable:
|
|
handler.start()
|
|
|
|
if self._worker is None:
|
|
self._worker = threading.Thread(
|
|
target=self.run,
|
|
args=[])
|
|
self._worker.daemon = True
|
|
self._worker.start()
|
|
print_debug(self._print_target, self.debug_level,
|
|
"Starting MeowRunner run...", DEBUG_INFO)
|
|
else:
|
|
msg = "Repeated calls to start have no effect."
|
|
print_debug(self._print_target, self.debug_level,
|
|
msg, DEBUG_WARNING)
|
|
raise RuntimeWarning(msg)
|
|
|
|
|
|
def stop(self)->None:
|
|
for monitor in self.monitors:
|
|
monitor.stop()
|
|
|
|
stopable = []
|
|
for handler_list in self.handlers.values():
|
|
for handler in handler_list:
|
|
if hasattr(handler, "stop") and handler not in stopable:
|
|
stopable.append()
|
|
for handler in stopable:
|
|
handler.stop()
|
|
|
|
if self._worker is None:
|
|
msg = "Cannot stop thread that is not started."
|
|
print_debug(self._print_target, self.debug_level,
|
|
msg, DEBUG_WARNING)
|
|
raise RuntimeWarning(msg)
|
|
else:
|
|
self._stop_pipe[1].send(1)
|
|
self._worker.join()
|
|
print_debug(self._print_target, self.debug_level,
|
|
"Worker thread stopped", DEBUG_INFO)
|
|
|
|
|
|
def _is_valid_monitors(self,
|
|
monitors:Union[BaseMonitor,list[BaseMonitor]])->None:
|
|
check_type(monitors, BaseMonitor, alt_types=[list[BaseMonitor]])
|
|
if type(monitors) == list:
|
|
valid_list(monitors, BaseMonitor, min_length=1)
|
|
|
|
def _is_valid_handlers(self,
|
|
handlers:Union[BaseHandler,list[BaseHandler]])->None:
|
|
check_type(handlers, BaseHandler, alt_types=[list[BaseHandler]])
|
|
if type(handlers) == list:
|
|
valid_list(handlers, BaseHandler, min_length=1)
|