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')