class Core: """Core class, contains core services (like listeners, executors, datapool)""" def __init__(self): self.cnf = cnf.get("core") self.logger = Logger("Core") self.logger.debug("Loading services") self._services = [] for service_name in self.cnf.get("services"): service = Loader.by_id('services', service_name) self._services.append(service) def start(self): """Starts all loaded services""" self.logger.info("Starting") for service in self._services: service.start() self.logger.info("Started") def stop(self): """Stops all loaded services""" self.logger.info("Stopping Core") for service in self._services: service.stop() self.logger.info("Stopped")
class Task(Loadable): def __init__(self, id, root): super().__init__(id, root) self._logger = Logger(self.__class__.__name__) def run(self, items): result = self._run(items) return result def _run(self, items): for item in items: try: item['steps'][self._id] = self._process(item) except Exception as e: self._logger.debug("Error occured while executing: %s", e) item['steps'][self._id] = False return items def _process(self, item): return True
class Remote: """Used to run remote Actions.. meh""" def __init__(self, ip, port): self._send_lock = threading.Lock() self._ip = ip self._port = port self._url = "tcp://%s:%s" % (ip, port) self._logger = Logger("Remote %s" % self._url) self._z_ctx = None self._z_sck = None def connect(self): self._z_ctx = zmq.Context() self._z_sck = self._z_ctx.socket(zmq.REQ) def run(self, action, data=None): msg = Message() msg.set('action', action) msg.set('data', data) rep = self._send_msg(msg) if rep.get('status') == False: self._logger.info(rep.get('data')) return rep def _send_msg(self, msg): self._logger.debug(msg.data()) self._send_lock.acquire() self._z_sck.connect(self._url) self._z_sck.send(msg.dump()) reply = Message.load(self._z_sck.recv()) self._send_lock.release() self._logger.debug(reply.data()) return reply
class Storage(Loadable): """Base class for storages""" def __init__(self, id, root): super().__init__(id, root) self._size = self.lcnf.get("size", 0) self._logger = Logger("Storage") self._logger.add_field('vname', self.__class__.__name__) def size(self): return self._size def count(self): return 0 def _get(self, block, filter): pass def _get_many(self, count, block, filter): items = [] for _ in range(count): items.append(self._get(block, filter)) return items def get(self, count=1, block=True, filter=None): """Returns items, removing them from storage""" self._logger.debug( "get|%s|%s|%s", count, block, inspect.stack()[1][0].f_locals["self"].__class__.__name__) items = [] if count == 1: items.append(self._get(block, filter)) elif count > 1: items = self._get_many(count, block, filter) return [i for i in items if i is not None] def _put(self, item, block): pass def _put_many(self, items, block): for i in items: if i is not None: self._put(i, block) def put(self, items, block=True): """Puts provided items""" self._logger.debug( "put|%s|%s|%s", len(items), block, inspect.stack()[1][0].f_locals["self"].__class__.__name__) if items: items = [i for i in items if i is not None] if len(items) == 1: self._put(items[0], block) elif len(items) > 1: self._put_many(items, block) def _find(self, filter): pass def find(self, filter): """Returns items without removing them from storage""" return self._find(filter) def _update(self, items, update): pass def update(self, items, update=None): """Updates provided items""" self._logger.debug( "update|%s|%s", len(items), inspect.stack()[1][0].f_locals["self"].__class__.__name__) if items: items = [i for i in items if i is not None] self._update(items, update) def _remove(self, items): pass def remove(self, items): """Removes provided items""" self._remove(items)
class Service(Loadable): """Base class for loadale service""" # service consists of running thread and storage attached def __init__(self, thread, id, root=cnf): super().__init__(id, root) self._data = Loader.by_id('storage', self.lcnf.get("storage")) self._stop_timeout = 10 self._running = False self._thread_to_run = thread self._run_thread = None self._logger = Logger('Service') self._init() def _init(self): pass def start(self): """Executes pre_start, starts thread and executes post_start""" self._logger.debug('pre_start') self._pre_start() self._logger.debug('start') self._running = True self._run_thread = Thread(target=self._thread_to_run) self._run_thread.daemon = True self._run_thread.start() self._logger.debug('post_start') self._post_start() self._logger.info('start finished') def stop(self): """Executes pre_stop, stops thread and executes post_stop""" self._logger.debug('pre_stop') self._pre_stop() self._logger.debug('stop') self._running = False self._run_thread.join(timeout=self._stop_timeout) self._logger.debug('post_stop') self._post_stop() self._logger.info('stop finished') def __run(self): while self._running: self._logger.debug('NOOP') sleep(1) def _pre_stop(self): pass def _post_stop(self): pass def _pre_start(self): pass def _post_start(self): pass