def test_cyclic_dependencies(self): """Échec du chargement à cause d'une dépendance circulaire.""" settings.reset() # La 1è règle dépend de la 2nde et vice-versa. get_registry().rules.register(TestRuleWithCyclicDependency1()) self.assertRaises(RuntimeError, get_registry().rules.register, TestRuleWithCyclicDependency2())
def test_rules_loading_twice(self): """Une même règle ne peut pas être chargée deux fois""" registry = get_registry() rules = [ TestRule1, TestRule1 ] for rule in rules: registry.rules.register(rule()) self.assertEquals(len(registry.rules), 1)
def __init__(self, dispatcher): self.__dispatcher = dispatcher self._stats = {} self._stats_tmp = {} self._runners = {} reg = get_registry() for rule_name in reg.rules.keys(): rule_obj = reg.rules.lookup(rule_name) self._runners[rule_name] = \ rule_runner.RuleRunner(dispatcher, rule_name, rule_obj)
def _computation_order(self, msg): if 'HighLevelServiceDepsRule' not in \ registry.get_registry().rules.keys(): LOGGER.warning(_("The rule 'vigilo.correlator_enterprise." "rules.hls_deps:HighLevelServiceDepsRule' " "must be loaded for computation orders to " "be handled properly.")) return defer.succeed(None) rule = registry.get_registry().rules.lookup('HighLevelServiceDepsRule') def eb(failure): if failure.check(defer.TimeoutError, error.ConnectionDone): LOGGER.info(_("The connection to memcached timed out. " "The message will be handled once more.")) return failure # Provoque le retraitement du message. LOGGER.warning(failure.getErrorMessage()) return None # on passe au suivant ctx = self._context_factory(msg["id"]) hls_names = set() for servicename in msg["hls"]: # TODO: adapter l'envoi if not isinstance(servicename, unicode): servicename = servicename.decode('utf-8') hls_names.add(servicename) hls_names = list(hls_names) d = ctx.set('impacted_hls', hls_names) d.addCallback(lambda _dummy: ctx.set('hostname', None)) d.addCallback(lambda _dummy: ctx.set('servicename', None)) d.addErrback(eb) d.addCallback(lambda _dummy: \ self.doWork( rule.compute_hls_states, self, msg["id"], None, None, hls_names ) ) return d
def test_rules_load_from_settings_twice(self): """ Une même règle configurée dans settings.ini ne peut être chargée deux fois """ settings["rules"] = { "nodeps1": "%s:%s" % (self.__module__, TestRule1.__name__), "nodeps2": "%s:%s" % (self.__module__, TestRule1.__name__), } registry = get_registry() registry._load_from_settings() print registry.rules.keys() self.assertEquals(len(registry.rules), 1)
def test_rules_load_from_settings(self): """ Les règles doivent pouvoir être chargées depuis une section [rules] de la conf """ settings["rules"] = { "rule1": "%s:%s" % (self.__module__, TestRule1.__name__), "rule2": "%s:%s" % (self.__module__, TestRule2.__name__), } registry = get_registry() registry._load_from_settings() print registry.rules.keys() self.assertEquals(len(registry.rules), 2) self.assertEquals(registry.rules.keys(), ["TestRule2", "TestRule1"])
def add_exec_stats(stats): # En cas d'absence de messages durant la dernière minute, # le temps d'exécution de chacune des règles est de 0.0 seconde. rule_stats = dict(zip( ["rule-%s" % rule for rule in registry.get_registry().rules.keys()], itertools.repeat(0.0) )) # On met à jour le dictionnaire avec les vraies stats d'exécution. rule_stats.update(self._executor.getStats()) stats.update(rule_stats) if self._correl_times: stats["rule-total"] = round(sum(self._correl_times) / len(self._correl_times), 5) self._correl_times = [] else: stats["rule-total"] = 0.0 return stats
def build_execution_tree(self): d = defer.Deferred() cache = {} rules_graph = get_registry().rules.rules_graph subdeferreds = [ self.__build_sub_execution_tree(cache, d, rules_graph, r) for r in rules_graph.nodes_iter() if not rules_graph.in_degree(r) ] # La corrélation sur l'alerte n'échoue que si TOUTES les règles # de corrélation ont échoué. Elle réussit lorsque TOUTES les règles # ont été exécutées. end = defer.DeferredList( subdeferreds, fireOnOneCallback=0, fireOnOneErrback=1, consumeErrors=True, ) return (d, end)
def test_rules_loading(self): """Chargement des règles de corrélation dans le désordre.""" registry = get_registry() # On charge volontairement la règle ayant une dépendance # avant sa dépendance, pour vérifier que le corrélateur est # capable de gérer le chargement dans n'importe quel ordre. rules = [ TestRuleWithDependency, TestRuleWithNoDependencies, ] for rule in rules: registry.rules.register(rule()) # Validation des dépendances. registry.check_dependencies() # On vérifie que toutes les règles demandées # ont bien pu être chargées. for rule in rules: self.assertEquals( registry.rules.lookup(rule.__name__).name, rule.__name__ )
def test_missing_rule_dependency(self): """Échec du chargement à cause d'une dépendance manquante.""" settings.reset() get_registry().rules.register(TestRuleWithDependency()) self.assertRaises(RuntimeError, get_registry().check_dependencies)
def tearDown(self): registry = get_registry() registry.rules.clear() settings.reset() settings.load_file('settings_tests.ini')