class EvaluatorWorker(GraphCloneWorkerBase):
def __init__(self, worker_id, task_queues, workers_num):
super(EvaluatorWorker, self).__init__(worker_id, task_queues)
self._workers_num = workers_num
self._evaluator = None
name = 'EvaluatorWorker'
def _init_instance(self):
scenario_repo = ScenarioRepository(self.worker_id, self._workers_num)
actions_callback = messaging.VitrageNotifier(
publisher_id='vitrage_evaluator', topics=[EVALUATOR_TOPIC]).notify
self._evaluator = ScenarioEvaluator(self._entity_graph,
scenario_repo,
actions_callback,
enabled=False)
self._evaluator.scenario_repo.log_enabled_scenarios()
def do_task(self, task):
super(EvaluatorWorker, self).do_task(task)
action = task[0]
if action == START_EVALUATION:
# fresh init (without snapshot) requires iterating the graph
self._evaluator.run_evaluator()
elif action == ENABLE_EVALUATION:
# init with a snapshot does not require iterating the graph
self._evaluator.enabled = True
elif action == RELOAD_TEMPLATES:
self._reload_templates()
elif action == TEMPLATE_ACTION:
(action, template_names, action_mode) = task
self._template_action(template_names, action_mode)
def _reload_templates(self):
LOG.info("reloading evaluator scenarios")
scenario_repo = ScenarioRepository(self.worker_id, self._workers_num)
self._evaluator.scenario_repo = scenario_repo
self._evaluator.scenario_repo.log_enabled_scenarios()
def _template_action(self, template_names, action_mode):
# Here, we create a temporary ScenarioRepo to execute the needed
# templates. Once _reload_templates is called, it will create a
# non temporary ScenarioRepo, to replace this one
scenario_repo = ScenarioRepository()
for s in scenario_repo._all_scenarios:
s.enabled = False
for template_name in template_names:
if s.id.startswith(template_name):
s.enabled = True
self._evaluator.scenario_repo = scenario_repo
self._evaluator.scenario_repo.log_enabled_scenarios()
self._evaluator.run_evaluator(action_mode)
class TemplateLoaderWorker(GraphCloneWorkerBase):
def __init__(self, worker_id, conf, task_queues, e_graph):
super(TemplateLoaderWorker, self).__init__(worker_id, conf,
task_queues, e_graph)
self._evaluator = None
name = 'TemplateLoaderWorker'
def _init_instance(self):
actions_callback = messaging.VitrageNotifier(
conf=self._conf,
publisher_id='vitrage_evaluator',
topics=[EVALUATOR_TOPIC]).notify
self._evaluator = ScenarioEvaluator(self._conf,
self._entity_graph,
None,
actions_callback,
enabled=False)
def do_task(self, task):
super(TemplateLoaderWorker, self).do_task(task)
action = task[0]
if action == TEMPLATE_ACTION:
(action, template_names, action_mode) = task
self._template_action(template_names, action_mode)
def _template_action(self, template_names, action_mode):
self._enable_evaluator_templates(template_names)
self._evaluator.run_evaluator(action_mode)
self._disable_evaluator()
def _enable_evaluator_templates(self, template_names):
scenario_repo = ScenarioRepository(self._conf)
for s in scenario_repo._all_scenarios:
s.enabled = False
for template_name in template_names:
if s.id.startswith(template_name):
s.enabled = True
self._evaluator.scenario_repo = scenario_repo
self._evaluator.scenario_repo.log_enabled_scenarios()
self._evaluator.enabled = True
def _disable_evaluator(self):
self._entity_graph.notifier._subscriptions = [] # Quick n dirty
self._evaluator.enabled = False
class EvaluatorWorker(GraphCloneWorkerBase):
def __init__(self, worker_id, conf, task_queues, e_graph, workers_num):
super(EvaluatorWorker, self).__init__(worker_id, conf, task_queues,
e_graph)
self._workers_num = workers_num
self._evaluator = None
name = 'EvaluatorWorker'
def _init_instance(self):
scenario_repo = ScenarioRepository(self._conf, self.worker_id,
self._workers_num)
actions_callback = messaging.VitrageNotifier(
conf=self._conf,
publisher_id='vitrage_evaluator',
topics=[EVALUATOR_TOPIC]).notify
self._evaluator = ScenarioEvaluator(self._conf,
self._entity_graph,
scenario_repo,
actions_callback,
enabled=False)
self._evaluator.scenario_repo.log_enabled_scenarios()
def do_task(self, task):
super(EvaluatorWorker, self).do_task(task)
action = task[0]
if action == START_EVALUATION:
# fresh init (without snapshot) requires iterating the graph
self._evaluator.run_evaluator()
elif action == ENABLE_EVALUATION:
# init with a snapshot does not require iterating the graph
self._evaluator.enabled = True
elif action == RELOAD_TEMPLATES:
self._reload_templates()
def _reload_templates(self):
LOG.info("reloading evaluator scenarios")
scenario_repo = ScenarioRepository(self._conf, self.worker_id,
self._workers_num)
self._evaluator.scenario_repo = scenario_repo
self._evaluator.scenario_repo.log_enabled_scenarios()
class EvaluatorWorker(os_service.Service):
def __init__(self,
conf,
task_queue,
entity_graph,
scenario_repo,
enabled=False):
super(EvaluatorWorker, self).__init__()
self._conf = conf
self._task_queue = task_queue
self._entity_graph = entity_graph
self._scenario_repo = scenario_repo
self._enabled = enabled
self._evaluator = None
def start(self):
super(EvaluatorWorker, self).start()
actions_callback = VitrageNotifier(conf=self._conf,
publisher_id='vitrage_evaluator',
topic=EVALUATOR_TOPIC).notify
self._entity_graph.notifier._subscriptions = [] # Quick n dirty
self._evaluator = ScenarioEvaluator(self._conf, self._entity_graph,
self._scenario_repo,
actions_callback, self._enabled)
self.tg.add_thread(self._read_queue)
LOG.info("EvaluatorWorkerService - Started!")
self._evaluator.scenario_repo.log_enabled_scenarios()
def _read_queue(self):
while True:
next_task = self._task_queue.get()
if next_task is POISON_PILL:
self._task_queue.task_done()
break
try:
self._do_task(next_task)
except Exception as e:
LOG.exception("Graph may not be in sync: exception %s", e)
self._task_queue.task_done()
# Evaluator queue may have been updated, thus the sleep:
time.sleep(0)
def _do_task(self, task):
(before, current, is_vertex, action) = task
if not action:
self._graph_update(before, current, is_vertex)
elif action == START_EVALUATION:
self._evaluator.run_evaluator()
def _graph_update(self, before, current, is_vertex):
if current:
if is_vertex:
self._entity_graph.add_vertex(current)
else:
self._entity_graph.add_edge(current)
else:
if is_vertex:
self._entity_graph.delete_vertex(before)
else:
self._entity_graph.delete_edge(before)
def stop(self, graceful=False):
super(EvaluatorWorker, self).stop(graceful)
self.tg.stop()
LOG.info("EvaluatorWorkerService - Stopped!")
