Implémentation d'un gestionnaire d'événements sommaire.

gestion/trigger/host.py

@@ -9,8 +9,22 @@
 # Author    : Pierre-Elliott Bécue <becue@crans.org>
 # License   : GPLv3
 # Date      : 28/04/2014
+"""This module provides host functions for trigger, such as the TriggerFactory which
+stores parsers and services metadata.
+"""
 
 import collections
+import functools
+
+import gestion.config.trigger as trigger_config
+from gestion.trigger.producer import EventProducer
+
+# Clogger
+import cranslib.clogger as clogger
+
+LOGGER = clogger.CLogger("trigger", "host.py/ack", trigger_config.log_level, trigger_config.debug)
+
+PRODUCER = EventProducer("trigger.civet")
 
 class TriggerFactory(object):
     """Factory containing which function is part of the trigger set
@@ -22,38 +36,96 @@ class TriggerFactory(object):
 
     @classmethod
     def register_service(cls, key, value):
+        """Stores the appropriate service in the factory"""
         cls._services[key] = value
 
     @classmethod
     def get_service(cls, key):
+        """Retrieves the appropriate service"""
         return cls._services.get(key, None)
 
     @classmethod
     def get_services(cls):
+        """Retrieves the list of all services"""
         return cls._services.values()
 
     @classmethod
     def register_parser(cls, keys, parser):
+        """Stores the attributes to watch and the function"""
         for key in keys:
             cls._parsers[key].append(parser)
 
     @classmethod
     def get_parser(cls, keyword):
+        """Restitutes the parser using keywords"""
         return cls._parsers[keyword]
 
-def record_service(func):
+def record_service(ack=True):
     """Records in the triggerfactory the function
 
     The function provided are services to regen
 
     """
-    TriggerFactory.register_service(func.func_name, func)
+    def enhance_func(func):
+        """Creates an enhanced function which tests if ack is True and
+        creates an ack if it's the case."""
+        @functools.wraps(func)
+        def enhanced_func(*args, **kwargs):
+            """Dummy"""
+            # The first arg is ob_id, execpt if kwargs.
+            if args:
+                __ob_id = args[0]
+            else:
+                __ob_id = kwargs['ob_id']
+
+            # The function does not return.
+            func(*args, **kwargs)
+
+            LOGGER.debug("[%r] Ran %r on (%r, %r)", __ob_id, func.func_name, args, kwargs, )
+
+            if ack:
+                # We send directly with routing key trigger.ack on the way.
+                # Thus, ack service does not need any parser.
+                routing_key = "ack"
+                body = (__ob_id, func.func_name)
+                LOGGER.debug("[%r] Ack %r.", __ob_id, body)
+                PRODUCER.send_message("trigger.%s" % (routing_key,), body)
+        TriggerFactory.register_service(func.func_name, enhanced_func)
+        return enhanced_func
+    return enhance_func
 
 def trigger_service(what):
+    """Calls the appropriate service"""
     return TriggerFactory.get_service(what)
 
 def record_parser(*args):
+    """Stores the function in TriggerFactory, using args as
+    keys for the dict"""
+
     def find_parser(func):
-        TriggerFactory.register_parser(args, func)
-        return func
+        """Adds the chaining_pos at the end of the return of functions."""
+        @functools.wraps(func)
+        def enhanced_func(*args, **kwargs):
+            """dummy"""
+            __ob_id = args[0]
+            ret = func(*args, **kwargs)
+            LOGGER.debug("[%r] In record_parser.find_parser, ran %r(%r, %r). Got %r.", __ob_id, func.func_name, args, kwargs, ret)
+            if ret is not None:
+                ret = [elem for elem in ret] + [getattr(func, "chaining_pos", 0)]
+                LOGGER.debug("[%r] In record_parser.find_parser, for %r got chaining_pos %r", __ob_id, func.func_name, ret[-1])
+            return ret
+        TriggerFactory.register_parser(args, enhanced_func)
+        return enhanced_func
+
     return find_parser
+
+def chaining(pos):
+    """Allows chaining of operations, by adding a position marker
+    on the function."""
+
+    def add_pos(func):
+        """Adds the chaining_pos variable to func"""
+        setattr(func, "chaining_pos", pos)
+        return func
+
+    return add_pos