1 files changed, 42 insertions, 10 deletions
diff --git a/peekaboo/ruleset/engine.py b/peekaboo/ruleset/engine.py
index 86b95e8..376cc08 100644
--- a/peekaboo/ruleset/engine.py
+++ b/peekaboo/ruleset/engine.py
@@ -28,7 +28,8 @@ import logging
 from peekaboo.ruleset import Result, RuleResult
 from peekaboo.ruleset.rules import *
 from peekaboo.toolbox.peekabooyar import ContainsPeekabooYarRule
-from peekaboo.exceptions import PeekabooAnalysisDeferred
+from peekaboo.exceptions import PeekabooAnalysisDeferred, \
+        PeekabooConfigException, PeekabooRulesetConfigError
 
 
 logger = logging.getLogger(__name__)
@@ -54,19 +55,51 @@ class RulesetEngine(object):
         FinalRule
     ]
 
-    def __init__(self, sample, ruleset_config, db_con):
-        self.sample = sample
+    def __init__(self, ruleset_config, db_con):
         self.config = ruleset_config
         self.db_con = db_con
 
         # create a lookup table from rule name to class
-        self.rules = {}
+        self.rule_classes = {}
         for known_rule in self.known_rules:
-            self.rules[known_rule.rule_name] = known_rule
+            self.rule_classes[known_rule.rule_name] = known_rule
 
-    def run(self):
-        for rule in self.config.rule_config('rules').get('rule'):
-            result = self.__exec_rule(self.sample, self.rules[rule])
+        try:
+            self.enabled_rules = self.config.getlist('rules', 'rule')
+        except PeekabooConfigException as error:
+            raise PeekabooRulesetConfigError(
+                'Ruleset configuration error: %s' % error)
+
+        self.validate_rule_config()
+
+    def validate_rule_config(self):
+        """ Validate the rule configuration in various ways.
+
+        @returns: None
+        @raises PeekabooRulesetConfigError: if configuration errors are found
+        """
+        if not self.enabled_rules:
+            raise PeekabooRulesetConfigError(
+                'No enabled rules found, check ruleset config.')
+
+        # check if unknown rules are enabled
+        known_rule_names = self.rule_classes.keys()
+        unknown_rules = set(self.enabled_rules) - set(known_rule_names)
+        if unknown_rules:
+            raise PeekabooRulesetConfigError(
+                'Unknown rule(s) enabled: %s' % ', '.join(unknown_rules))
+
+        config_sections = []
+        for rule in self.enabled_rules:
+            # not passing database connection. Needs revisiting if a rule
+            # ever wants to retrieve configuration from the database. For
+            # now at least rule constructor and get_config() need to be
+            # able to cope without it.
+            rule = self.rule_classes[rule](self.config)
+
+    def run(self, sample):
+        for rule in self.enabled_rules:
+            result = self.__exec_rule(sample, self.rule_classes[rule])
             if not result.further_analysis:
                 return
 
@@ -80,8 +113,7 @@ class RulesetEngine(object):
         logger.debug("Processing rule '%s' for %s" % (rule_name, sample))
 
         try:
-            rule_config = self.config.rule_config(rule_name)
-            rule = rule_class(config=rule_config, db_con=self.db_con)
+            rule = rule_class(config=self.config, db_con=self.db_con)
             result = rule.evaluate(sample)
             sample.add_rule_result(result)
         except PeekabooAnalysisDeferred: