Пример #1
0
 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())
Пример #2
0
 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)
Пример #3
0
 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)
Пример #4
0
    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
Пример #5
0
 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)
Пример #6
0
 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"])
Пример #7
0
 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
Пример #8
0
    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)
Пример #9
0
    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__
            )
Пример #10
0
 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)
Пример #11
0
 def tearDown(self):
     registry = get_registry()
     registry.rules.clear()
     settings.reset()
     settings.load_file('settings_tests.ini')