Checkpoint #2

st2common/st2common/models/db/trigger.py

@@ -108,7 +108,7 @@ class TriggerInstanceDB(stormbase.StormFoundationDB):
         payload (dict): payload specific to the occurrence.
         occurrence_time (datetime): time of occurrence of the trigger.
     """
-    trigger = me.StringField()
+    trigger = me.DictField()
     payload = stormbase.EscapedDictField()
     occurrence_time = me.DateTimeField()
     status = me.StringField(

st2reactor/st2reactor/container/utils.py

@@ -40,6 +40,13 @@ def create_trigger_instance(trigger, payload, occurrence_time, raise_on_no_trigg
     # TODO: This is nasty, this should take a unique reference and not a dict
     if isinstance(trigger, six.string_types):
         trigger_db = TriggerService.get_trigger_db_by_ref(trigger)
+        if not trigger_db:
+            LOG.debug('No trigger in db for %s', trigger)
+            if raise_on_no_trigger:
+                raise StackStormDBObjectNotFoundError('Trigger not found for %s', trigger)
+            return None
+        else:
+            trigger_ptr = {'ref': trigger_db.get_reference().ref}
     else:
         # If id / uid is available we try to look up Trigger by id. This way we can avoid bug in
         # pymongo / mongoengine related to "parameters" dictionary lookups
@@ -49,10 +56,10 @@ def create_trigger_instance(trigger, payload, occurrence_time, raise_on_no_trigg
         # TODO: Remove parameters dictionary look up when we can confirm each trigger dictionary
         # passed to this method always contains id or uid
         if trigger_id:
-            LOG.debug('Looking up TriggerDB by id: %s', trigger_id)
+            LOG.info('Looking up TriggerDB by id: %s', trigger_id)
             trigger_db = TriggerService.get_trigger_db_by_id(id=trigger_id)
         elif trigger_uid:
-            LOG.debug('Looking up TriggerDB by uid: %s', trigger_uid)
+            LOG.info('Looking up TriggerDB by uid: %s', trigger_uid)
             trigger_db = TriggerService.get_trigger_db_by_uid(uid=trigger_uid)
         else:
             # Last resort - look it up by parameters
@@ -64,16 +71,20 @@ def create_trigger_instance(trigger, payload, occurrence_time, raise_on_no_trigg
             trigger_db = TriggerService.get_trigger_db_given_type_and_params(type=trigger_type,
                                                                              parameters=parameters)
 
-    if trigger_db is None:
-        LOG.debug('No trigger in db for %s', trigger)
-        if raise_on_no_trigger:
-            raise StackStormDBObjectNotFoundError('Trigger not found for %s', trigger)
-        return None
-
-    trigger_ref = trigger_db.get_reference().ref
+        if not trigger_db:
+            LOG.debug('No trigger in db for %s', trigger)
+            if raise_on_no_trigger:
+                raise StackStormDBObjectNotFoundError('Trigger not found for %s', trigger)
+            return None
+        else:
+            trigger_ptr = {
+                'ref': trigger_db.get_reference().ref,
+                'type': trigger_db.type,
+                'parameters': trigger_db.parameters
+            }
 
     trigger_instance = TriggerInstanceDB()
-    trigger_instance.trigger = trigger_ref
+    trigger_instance.trigger = trigger_ptr
     trigger_instance.payload = payload
     trigger_instance.occurrence_time = occurrence_time
     trigger_instance.status = TRIGGER_INSTANCE_PENDING

st2reactor/st2reactor/rules/engine.py

@@ -13,8 +13,11 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+import six
+
 from st2common import log as logging
 from st2common.persistence.rule import Rule
+from st2common.services.triggers import get_trigger_db_given_type_and_params
 from st2common.services.triggers import get_trigger_db_by_ref
 from st2reactor.rules.enforcer import RuleEnforcer
 from st2reactor.rules.matcher import RulesMatcher
@@ -27,20 +30,53 @@ def handle_trigger_instance(self, trigger_instance):
         # Find matching rules for trigger instance.
         matching_rules = self.get_matching_rules_for_trigger(trigger_instance)
 
-        # Create rule enforcers.
-        enforcers = self.create_rule_enforcers(trigger_instance, matching_rules)
+        if matching_rules:
+            # Create rule enforcers.
+            enforcers = self.create_rule_enforcers(trigger_instance, matching_rules)
 
-        # Enforce the rules.
-        self.enforce_rules(enforcers)
+            # Enforce the rules.
+            self.enforce_rules(enforcers)
+        else:
+            LOG.info('No matching rules found for trigger instance %s.', trigger_instance)
 
     def get_matching_rules_for_trigger(self, trigger_instance):
         trigger = trigger_instance.trigger
-        trigger = get_trigger_db_by_ref(trigger_instance.trigger)
-        rules = Rule.query(trigger=trigger_instance.trigger, enabled=True)
+
+        trigger_type_with_params = False
+
+        if getattr(trigger, 'type', None) and getattr(trigger, 'parameters', None):
+            trigger_type_with_params = True
+
+        LOG.info('Type(trigger) = %s', type(trigger))
+        trigger_ptr = None
+        if trigger_type_with_params:
+            trigger_type = trigger.type
+            trigger_params = trigger.parameters
+            trigger_db = get_trigger_db_given_type_and_params(
+                type=trigger_type,
+                parameters=trigger_params
+            )
+            if trigger_db:
+                trigger_ptr = {
+                    'ref': trigger_db.get_reference().ref,
+                    'type': trigger_type,
+                    'parameters': trigger_params
+                }
+        else:
+            trigger_db = get_trigger_db_by_ref(trigger_instance.trigger.ref)
+            if trigger_db:
+                trigger_ptr = trigger_db.get_reference().ref
+
+
+        if not trigger_ptr:
+            LOG.error('No matching trigger found for trigger instance %s.', trigger_instance)
+            return None
+
+        rules = Rule.query(trigger=trigger_ptr, enabled=True)
         LOG.info('Found %d rules defined for trigger %s (type=%s)', len(rules), trigger['name'],
                  trigger['type'])
         matcher = RulesMatcher(trigger_instance=trigger_instance,
-                               trigger=trigger, rules=rules)
+                               trigger=trigger_db, rules=rules)
 
         matching_rules = matcher.get_matching_rules()
         LOG.info('Matched %s rule(s) for trigger_instance %s (type=%s)', len(matching_rules),