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
