def to_model(cls, rule):
name = getattr(rule, 'name', None)
description = getattr(rule, 'description', None)
# Create a trigger for the provided rule
trigger_db = TriggerService.create_trigger_db_from_rule(rule)
trigger = reference.get_str_resource_ref_from_model(trigger_db)
criteria = dict(getattr(rule, 'criteria', {}))
pack = getattr(rule, 'pack', DEFAULT_PACK_NAME)
ref = ResourceReference.to_string_reference(pack=pack, name=name)
# Validate criteria
validator.validate_criteria(criteria)
# Validate trigger parameters
validator.validate_trigger_parameters(trigger_db=trigger_db)
action = ActionExecutionSpecDB(ref=rule.action['ref'],
parameters=rule.action['parameters'])
enabled = rule.enabled
tags = TagsHelper.to_model(getattr(rule, 'tags', []))
model = cls.model(name=name, description=description, pack=pack, ref=ref, trigger=trigger,
criteria=criteria, action=action, enabled=enabled, tags=tags)
return model
def to_model(cls, rule):
kwargs = {}
kwargs['name'] = getattr(rule, 'name', None)
kwargs['description'] = getattr(rule, 'description', None)
# Create a trigger for the provided rule
trigger_db = TriggerService.create_trigger_db_from_rule(rule)
kwargs['trigger'] = reference.get_str_resource_ref_from_model(trigger_db)
# Validate trigger parameters
validator.validate_trigger_parameters(trigger_db=trigger_db)
kwargs['pack'] = getattr(rule, 'pack', DEFAULT_PACK_NAME)
kwargs['ref'] = ResourceReference.to_string_reference(pack=kwargs['pack'],
name=kwargs['name'])
# Validate criteria
kwargs['criteria'] = dict(getattr(rule, 'criteria', {}))
validator.validate_criteria(kwargs['criteria'])
kwargs['action'] = ActionExecutionSpecDB(ref=rule.action['ref'],
parameters=rule.action.get('parameters', {}))
rule_type = dict(getattr(rule, 'type', {}))
if rule_type:
kwargs['type'] = RuleTypeSpecDB(ref=rule_type['ref'],
parameters=rule_type.get('parameters', {}))
kwargs['enabled'] = getattr(rule, 'enabled', False)
kwargs['tags'] = TagsHelper.to_model(getattr(rule, 'tags', []))
model = cls.model(**kwargs)
return model
def to_model(cls, rule):
name = getattr(rule, 'name', None)
description = getattr(rule, 'description', None)
# Create a trigger for the provided rule
trigger_db = TriggerService.create_trigger_db_from_rule(rule)
trigger = reference.get_str_resource_ref_from_model(trigger_db)
criteria = dict(getattr(rule, 'criteria', {}))
pack = getattr(rule, 'pack', DEFAULT_PACK_NAME)
ref = ResourceReference.to_string_reference(pack=pack, name=name)
# Validate criteria
validator.validate_criteria(criteria)
# Validate trigger parameters
validator.validate_trigger_parameters(trigger_db=trigger_db)
action = ActionExecutionSpecDB(ref=rule.action['ref'],
parameters=rule.action['parameters'])
enabled = rule.enabled
tags = TagsHelper.to_model(getattr(rule, 'tags', []))
model = cls.model(name=name,
description=description,
pack=pack,
ref=ref,
trigger=trigger,
criteria=criteria,
action=action,
enabled=enabled,
tags=tags)
return model
def test_triggered_execution(self):
docs = {
'trigger_type':
copy.deepcopy(fixture.ARTIFACTS['trigger_type']),
'trigger':
copy.deepcopy(fixture.ARTIFACTS['trigger']),
'rule':
copy.deepcopy(fixture.ARTIFACTS['rule']),
'trigger_instance':
copy.deepcopy(fixture.ARTIFACTS['trigger_instance'])
}
# Trigger an action execution.
trigger_type = TriggerType.add_or_update(
TriggerTypeAPI.to_model(TriggerTypeAPI(**docs['trigger_type'])))
trigger = Trigger.add_or_update(
TriggerAPI.to_model(TriggerAPI(**docs['trigger'])))
rule = RuleAPI.to_model(RuleAPI(**docs['rule']))
rule.trigger = reference.get_str_resource_ref_from_model(trigger)
rule = Rule.add_or_update(rule)
trigger_instance = TriggerInstance.add_or_update(
TriggerInstanceAPI.to_model(
TriggerInstanceAPI(**docs['trigger_instance'])))
enforcer = RuleEnforcer(trigger_instance, rule)
enforcer.enforce()
# Wait for the action execution to complete and then confirm outcome.
liveaction = LiveAction.get(
context__trigger_instance__id=str(trigger_instance.id))
self.assertIsNotNone(liveaction)
liveaction = LiveAction.get_by_id(str(liveaction.id))
self.assertEqual(liveaction.status, LIVEACTION_STATUS_FAILED)
execution = self._get_action_execution(liveaction__id=str(
liveaction.id),
raise_exception=True)
self.assertDictEqual(execution.trigger,
vars(TriggerAPI.from_model(trigger)))
self.assertDictEqual(execution.trigger_type,
vars(TriggerTypeAPI.from_model(trigger_type)))
self.assertDictEqual(
execution.trigger_instance,
vars(TriggerInstanceAPI.from_model(trigger_instance)))
self.assertDictEqual(execution.rule, vars(RuleAPI.from_model(rule)))
action = action_utils.get_action_by_ref(liveaction.action)
self.assertDictEqual(execution.action,
vars(ActionAPI.from_model(action)))
runner = RunnerType.get_by_name(action.runner_type['name'])
self.assertDictEqual(execution.runner,
vars(RunnerTypeAPI.from_model(runner)))
liveaction = LiveAction.get_by_id(str(liveaction.id))
self.assertEqual(execution.start_timestamp, liveaction.start_timestamp)
self.assertEqual(execution.end_timestamp, liveaction.end_timestamp)
self.assertEqual(execution.result, liveaction.result)
self.assertEqual(execution.status, liveaction.status)
self.assertEqual(execution.context, liveaction.context)
self.assertEqual(execution.liveaction['callback'], liveaction.callback)
self.assertEqual(execution.liveaction['action'], liveaction.action)
def test_triggered_execution(self):
docs = {
'trigger_type':
copy.deepcopy(fixture.ARTIFACTS['trigger_type']),
'trigger':
copy.deepcopy(fixture.ARTIFACTS['trigger']),
'rule':
copy.deepcopy(fixture.ARTIFACTS['rule']),
'trigger_instance':
copy.deepcopy(fixture.ARTIFACTS['trigger_instance'])
}
# Trigger an action execution.
trigger_type = TriggerType.add_or_update(
TriggerTypeAPI.to_model(TriggerTypeAPI(**docs['trigger_type'])))
trigger = Trigger.add_or_update(
TriggerAPI.to_model(TriggerAPI(**docs['trigger'])))
rule = RuleAPI.to_model(RuleAPI(**docs['rule']))
rule.trigger = reference.get_str_resource_ref_from_model(trigger)
rule = Rule.add_or_update(rule)
trigger_instance = TriggerInstance.add_or_update(
TriggerInstanceAPI.to_model(
TriggerInstanceAPI(**docs['trigger_instance'])))
enforcer = RuleEnforcer(trigger_instance, rule)
enforcer.enforce()
# Wait for the action execution to complete and then confirm outcome.
execution = ActionExecution.get(
context__trigger_instance__id=str(trigger_instance.id))
self.assertIsNotNone(execution)
execution = ActionExecution.get_by_id(str(execution.id))
self.assertEqual(execution.status, ACTIONEXEC_STATUS_SUCCEEDED)
history = ActionExecutionHistory.get(execution__id=str(execution.id),
raise_exception=True)
self.assertDictEqual(history.trigger,
vars(TriggerAPI.from_model(trigger)))
self.assertDictEqual(history.trigger_type,
vars(TriggerTypeAPI.from_model(trigger_type)))
self.assertDictEqual(
history.trigger_instance,
vars(TriggerInstanceAPI.from_model(trigger_instance)))
self.assertDictEqual(history.rule, vars(RuleAPI.from_model(rule)))
action_ref = ResourceReference.from_string_reference(
ref=execution.action)
action, _ = action_utils.get_action_by_dict({
'name': action_ref.name,
'pack': action_ref.pack
})
self.assertDictEqual(history.action,
vars(ActionAPI.from_model(action)))
runner = RunnerType.get_by_name(action.runner_type['name'])
self.assertDictEqual(history.runner,
vars(RunnerTypeAPI.from_model(runner)))
execution = ActionExecution.get_by_id(str(execution.id))
self.assertDictEqual(history.execution,
vars(ActionExecutionAPI.from_model(execution)))
def test_rule_lookup(self):
triggertype = ReactorModelTest._create_save_triggertype()
trigger = ReactorModelTest._create_save_trigger(triggertype)
runnertype = ActionModelTest._create_save_runnertype()
action = ActionModelTest._create_save_action(runnertype)
saved = ReactorModelTest._create_save_rule(trigger, action)
retrievedrules = Rule.query(trigger=reference.get_str_resource_ref_from_model(trigger))
self.assertEqual(1, len(retrievedrules), 'No rules found.')
for retrievedrule in retrievedrules:
self.assertEqual(saved.id, retrievedrule.id, 'Incorrect rule returned.')
ReactorModelTest._delete([saved, trigger, action, runnertype, triggertype])
def test_rule_lookup(self):
triggertype = ReactorModelTest._create_save_triggertype()
trigger = ReactorModelTest._create_save_trigger(triggertype)
runnertype = ActionModelTest._create_save_runnertype()
action = ActionModelTest._create_save_action(runnertype)
saved = ReactorModelTest._create_save_rule(trigger, action)
retrievedrules = Rule.query(trigger=reference.get_str_resource_ref_from_model(trigger))
self.assertEqual(1, len(retrievedrules), 'No rules found.')
for retrievedrule in retrievedrules:
self.assertEqual(saved.id, retrievedrule.id, 'Incorrect rule returned.')
ReactorModelTest._delete([saved, trigger, action, runnertype, triggertype])
def test_rule_lookup_disabled(self):
triggertype = ReactorModelTest._create_save_triggertype()
trigger = ReactorModelTest._create_save_trigger(triggertype)
runnertype = ActionModelTest._create_save_runnertype()
action = ActionModelTest._create_save_action(runnertype)
saved = ReactorModelTest._create_save_rule(trigger, action, False)
retrievedrules = Rule.query(trigger=reference.get_str_resource_ref_from_model(trigger), enabled=False)
self.assertEqual(1, len(retrievedrules), "Error looking up enabled rules.")
for retrievedrule in retrievedrules:
self.assertEqual(saved.id, retrievedrule.id, "Incorrect rule returned.")
ReactorModelTest._delete([saved, trigger, action, runnertype, triggertype])
def to_model(cls, rule):
model = super(cls, cls).to_model(rule)
trigger_db = TriggerService.create_trigger_db_from_rule(rule)
model.trigger = reference.get_str_resource_ref_from_model(trigger_db)
model.criteria = dict(getattr(rule, 'criteria', {}))
validator.validate_criteria(model.criteria)
model.action = ActionExecutionSpecDB()
model.action.ref = rule.action['ref']
model.action.parameters = rule.action['parameters']
model.enabled = rule.enabled
model.tags = TagsHelper.to_model(getattr(rule, 'tags', []))
return model
def _create_save_rule(trigger, action=None, enabled=True):
created = RuleDB()
created.name = 'rule-1'
created.description = ''
created.enabled = enabled
created.trigger = reference.get_str_resource_ref_from_model(trigger)
created.criteria = {}
created.action = ActionExecutionSpecDB()
action_ref = ResourceReference(pack=action.pack, name=action.name).ref
created.action.ref = action_ref
created.action.pack = action.pack
created.action.parameters = {}
return Rule.add_or_update(created)
def _create_save_rule(trigger, action=None, enabled=True):
created = RuleDB()
created.name = 'rule-1'
created.description = ''
created.enabled = enabled
created.trigger = reference.get_str_resource_ref_from_model(trigger)
created.criteria = {}
created.action = ActionExecutionSpecDB()
action_ref = ResourceReference(pack=action.pack, name=action.name).ref
created.action.ref = action_ref
created.action.pack = action.pack
created.action.parameters = {}
return Rule.add_or_update(created)
def test_triggered_execution(self):
docs = {
'trigger_type': copy.deepcopy(fixture.ARTIFACTS['trigger_type']),
'trigger': copy.deepcopy(fixture.ARTIFACTS['trigger']),
'rule': copy.deepcopy(fixture.ARTIFACTS['rule']),
'trigger_instance': copy.deepcopy(fixture.ARTIFACTS['trigger_instance'])}
# Trigger an action execution.
trigger_type = TriggerType.add_or_update(
TriggerTypeAPI.to_model(TriggerTypeAPI(**docs['trigger_type'])))
trigger = Trigger.add_or_update(TriggerAPI.to_model(TriggerAPI(**docs['trigger'])))
rule = RuleAPI.to_model(RuleAPI(**docs['rule']))
rule.trigger = reference.get_str_resource_ref_from_model(trigger)
rule = Rule.add_or_update(rule)
trigger_instance = TriggerInstance.add_or_update(
TriggerInstanceAPI.to_model(TriggerInstanceAPI(**docs['trigger_instance'])))
trace_service.add_or_update_given_trace_context(
trace_context={'trace_tag': 'test_triggered_execution_trace'},
trigger_instances=[str(trigger_instance.id)])
enforcer = RuleEnforcer(trigger_instance, rule)
enforcer.enforce()
# Wait for the action execution to complete and then confirm outcome.
liveaction = LiveAction.get(context__trigger_instance__id=str(trigger_instance.id))
self.assertIsNotNone(liveaction)
liveaction = self._wait_on_status(liveaction, action_constants.LIVEACTION_STATUS_FAILED)
execution = self._get_action_execution(
liveaction__id=str(liveaction.id),
raise_exception=True
)
self.assertDictEqual(execution.trigger, vars(TriggerAPI.from_model(trigger)))
self.assertDictEqual(execution.trigger_type, vars(TriggerTypeAPI.from_model(trigger_type)))
self.assertDictEqual(execution.trigger_instance,
vars(TriggerInstanceAPI.from_model(trigger_instance)))
self.assertDictEqual(execution.rule, vars(RuleAPI.from_model(rule)))
action = action_utils.get_action_by_ref(liveaction.action)
self.assertDictEqual(execution.action, vars(ActionAPI.from_model(action)))
runner = RunnerType.get_by_name(action.runner_type['name'])
self.assertDictEqual(execution.runner, vars(RunnerTypeAPI.from_model(runner)))
liveaction = LiveAction.get_by_id(str(liveaction.id))
self.assertEqual(execution.start_timestamp, liveaction.start_timestamp)
self.assertEqual(execution.end_timestamp, liveaction.end_timestamp)
self.assertEqual(execution.result, liveaction.result)
self.assertEqual(execution.status, liveaction.status)
self.assertEqual(execution.context, liveaction.context)
self.assertEqual(execution.liveaction['callback'], liveaction.callback)
self.assertEqual(execution.liveaction['action'], liveaction.action)
def _create_save_rule(trigger, action=None, enabled=True):
name = "rule-1"
pack = "default"
ref = ResourceReference.to_string_reference(name=name, pack=pack)
created = RuleDB(name=name, pack=pack, ref=ref)
created.description = ""
created.enabled = enabled
created.trigger = reference.get_str_resource_ref_from_model(trigger)
created.criteria = {}
created.action = ActionExecutionSpecDB()
action_ref = ResourceReference(pack=action.pack, name=action.name).ref
created.action.ref = action_ref
created.action.pack = action.pack
created.action.parameters = {}
return Rule.add_or_update(created)
def _create_save_rule(trigger, action=None, enabled=True):
name = "rule-1"
pack = "default"
ref = ResourceReference.to_string_reference(name=name, pack=pack)
created = RuleDB(name=name, pack=pack, ref=ref)
created.description = ""
created.enabled = enabled
created.trigger = reference.get_str_resource_ref_from_model(trigger)
created.criteria = {}
created.action = ActionExecutionSpecDB()
action_ref = ResourceReference(pack=action.pack, name=action.name).ref
created.action.ref = action_ref
created.action.pack = action.pack
created.action.parameters = {}
return Rule.add_or_update(created)
def to_model(cls, rule):
model = super(cls, cls).to_model(rule)
trigger_db = TriggerService.create_trigger_db_from_rule(rule)
model.trigger = reference.get_str_resource_ref_from_model(trigger_db)
model.criteria = dict(getattr(rule, 'criteria', {}))
for oldkey, value in six.iteritems(model.criteria):
newkey = oldkey.replace('.', u'\u2024')
if oldkey != newkey:
model.criteria[newkey] = value
del model.criteria[oldkey]
validator.validate_criteria(model.criteria)
model.action = ActionExecutionSpecDB()
model.action.ref = rule.action['ref']
model.action.parameters = rule.action['parameters']
model.enabled = rule.enabled
return model
def test_rule_lookup_disabled(self):
triggertype = ReactorModelTestCase._create_save_triggertype()
trigger = ReactorModelTestCase._create_save_trigger(triggertype)
runnertype = ActionModelTestCase._create_save_runnertype()
action = ActionModelTestCase._create_save_action(runnertype)
saved = ReactorModelTestCase._create_save_rule(trigger, action, False)
retrievedrules = Rule.query(
trigger=reference.get_str_resource_ref_from_model(trigger),
enabled=False)
self.assertEqual(1, len(retrievedrules),
'Error looking up enabled rules.')
for retrievedrule in retrievedrules:
self.assertEqual(saved.id, retrievedrule.id,
'Incorrect rule returned.')
ReactorModelTestCase._delete(
[saved, trigger, action, runnertype, triggertype])
def to_model(cls, rule):
kwargs = {}
kwargs["name"] = getattr(rule, "name", None)
kwargs["description"] = getattr(rule, "description", None)
# Validate trigger parameters
# Note: This must happen before we create a trigger, otherwise create trigger could fail
# with a cryptic error
trigger = getattr(rule, "trigger", {})
trigger_type_ref = trigger.get("type", None)
parameters = trigger.get("parameters", {})
validator.validate_trigger_parameters(
trigger_type_ref=trigger_type_ref, parameters=parameters
)
# Create a trigger for the provided rule
trigger_db = TriggerService.create_trigger_db_from_rule(rule)
kwargs["trigger"] = reference.get_str_resource_ref_from_model(trigger_db)
kwargs["pack"] = getattr(rule, "pack", DEFAULT_PACK_NAME)
kwargs["ref"] = ResourceReference.to_string_reference(
pack=kwargs["pack"], name=kwargs["name"]
)
# Validate criteria
kwargs["criteria"] = dict(getattr(rule, "criteria", {}))
validator.validate_criteria(kwargs["criteria"])
kwargs["action"] = ActionExecutionSpecDB(
ref=rule.action["ref"], parameters=rule.action.get("parameters", {})
)
rule_type = dict(getattr(rule, "type", {}))
if rule_type:
kwargs["type"] = RuleTypeSpecDB(
ref=rule_type["ref"], parameters=rule_type.get("parameters", {})
)
kwargs["enabled"] = getattr(rule, "enabled", False)
kwargs["context"] = getattr(rule, "context", dict())
kwargs["tags"] = TagsHelper.to_model(getattr(rule, "tags", []))
kwargs["metadata_file"] = getattr(rule, "metadata_file", None)
model = cls.model(**kwargs)
return model
def to_model(cls, rule):
kwargs = {}
kwargs['name'] = getattr(rule, 'name', None)
kwargs['description'] = getattr(rule, 'description', None)
# Validate trigger parameters
# Note: This must happen before we create a trigger, otherwise create trigger could fail
# with a cryptic error
trigger = getattr(rule, 'trigger', {})
trigger_type_ref = trigger.get('type', None)
parameters = trigger.get('parameters', {})
validator.validate_trigger_parameters(
trigger_type_ref=trigger_type_ref, parameters=parameters)
# Create a trigger for the provided rule
trigger_db = TriggerService.create_trigger_db_from_rule(rule)
kwargs['trigger'] = reference.get_str_resource_ref_from_model(
trigger_db)
kwargs['pack'] = getattr(rule, 'pack', DEFAULT_PACK_NAME)
kwargs['ref'] = ResourceReference.to_string_reference(
pack=kwargs['pack'], name=kwargs['name'])
# Validate criteria
kwargs['criteria'] = dict(getattr(rule, 'criteria', {}))
validator.validate_criteria(kwargs['criteria'])
kwargs['action'] = ActionExecutionSpecDB(ref=rule.action['ref'],
parameters=rule.action.get(
'parameters', {}))
rule_type = dict(getattr(rule, 'type', {}))
if rule_type:
kwargs['type'] = RuleTypeSpecDB(ref=rule_type['ref'],
parameters=rule_type.get(
'parameters', {}))
kwargs['enabled'] = getattr(rule, 'enabled', False)
kwargs['context'] = getattr(rule, 'context', dict())
kwargs['tags'] = TagsHelper.to_model(getattr(rule, 'tags', []))
kwargs['metadata_file'] = getattr(rule, 'metadata_file', None)
model = cls.model(**kwargs)
return model
def to_model(cls, rule):
kwargs = {}
kwargs['name'] = getattr(rule, 'name', None)
kwargs['description'] = getattr(rule, 'description', None)
# Validate trigger parameters
# Note: This must happen before we create a trigger, otherwise create trigger could fail
# with a cryptic error
trigger = getattr(rule, 'trigger', {})
trigger_type_ref = trigger.get('type', None)
parameters = trigger.get('parameters', {})
validator.validate_trigger_parameters(trigger_type_ref=trigger_type_ref,
parameters=parameters)
# Create a trigger for the provided rule
trigger_db = TriggerService.create_trigger_db_from_rule(rule)
kwargs['trigger'] = reference.get_str_resource_ref_from_model(trigger_db)
kwargs['pack'] = getattr(rule, 'pack', DEFAULT_PACK_NAME)
kwargs['ref'] = ResourceReference.to_string_reference(pack=kwargs['pack'],
name=kwargs['name'])
# Validate criteria
kwargs['criteria'] = dict(getattr(rule, 'criteria', {}))
validator.validate_criteria(kwargs['criteria'])
kwargs['action'] = ActionExecutionSpecDB(ref=rule.action['ref'],
parameters=rule.action.get('parameters', {}))
rule_type = dict(getattr(rule, 'type', {}))
if rule_type:
kwargs['type'] = RuleTypeSpecDB(ref=rule_type['ref'],
parameters=rule_type.get('parameters', {}))
kwargs['enabled'] = getattr(rule, 'enabled', False)
kwargs['context'] = getattr(rule, 'context', dict())
kwargs['tags'] = TagsHelper.to_model(getattr(rule, 'tags', []))
kwargs['metadata_file'] = getattr(rule, 'metadata_file', None)
model = cls.model(**kwargs)
return model
def test_triggered_execution(self):
docs = {
'trigger_type': copy.deepcopy(fixture.ARTIFACTS['trigger_type']),
'trigger': copy.deepcopy(fixture.ARTIFACTS['trigger']),
'rule': copy.deepcopy(fixture.ARTIFACTS['rule']),
'trigger_instance': copy.deepcopy(fixture.ARTIFACTS['trigger_instance'])}
# Trigger an action execution.
trigger_type = TriggerType.add_or_update(
TriggerTypeAPI.to_model(TriggerTypeAPI(**docs['trigger_type'])))
trigger = Trigger.add_or_update(TriggerAPI.to_model(TriggerAPI(**docs['trigger'])))
rule = RuleAPI.to_model(RuleAPI(**docs['rule']))
rule.trigger = reference.get_str_resource_ref_from_model(trigger)
rule = Rule.add_or_update(rule)
trigger_instance = TriggerInstance.add_or_update(
TriggerInstanceAPI.to_model(TriggerInstanceAPI(**docs['trigger_instance'])))
enforcer = RuleEnforcer(trigger_instance, rule)
enforcer.enforce()
# Wait for the action execution to complete and then confirm outcome.
execution = ActionExecution.get(context__trigger_instance__id=str(trigger_instance.id))
self.assertIsNotNone(execution)
execution = ActionExecution.get_by_id(str(execution.id))
self.assertEqual(execution.status, ACTIONEXEC_STATUS_SUCCEEDED)
history = ActionExecutionHistory.get(execution__id=str(execution.id), raise_exception=True)
self.assertDictEqual(history.trigger, vars(TriggerAPI.from_model(trigger)))
self.assertDictEqual(history.trigger_type, vars(TriggerTypeAPI.from_model(trigger_type)))
self.assertDictEqual(history.trigger_instance,
vars(TriggerInstanceAPI.from_model(trigger_instance)))
self.assertDictEqual(history.rule, vars(RuleAPI.from_model(rule)))
action_ref = ResourceReference.from_string_reference(ref=execution.action)
action, _ = action_utils.get_action_by_dict(
{'name': action_ref.name, 'pack': action_ref.pack})
self.assertDictEqual(history.action, vars(ActionAPI.from_model(action)))
runner = RunnerType.get_by_name(action.runner_type['name'])
self.assertDictEqual(history.runner, vars(RunnerTypeAPI.from_model(runner)))
execution = ActionExecution.get_by_id(str(execution.id))
self.assertDictEqual(history.execution, vars(ActionExecutionAPI.from_model(execution)))
def to_model(cls, rule):
kwargs = {}
kwargs['name'] = getattr(rule, 'name', None)
kwargs['description'] = getattr(rule, 'description', None)
# Create a trigger for the provided rule
trigger_db = TriggerService.create_trigger_db_from_rule(rule)
kwargs['trigger'] = reference.get_str_resource_ref_from_model(
trigger_db)
# Validate trigger parameters
validator.validate_trigger_parameters(trigger_db=trigger_db)
kwargs['pack'] = getattr(rule, 'pack', DEFAULT_PACK_NAME)
kwargs['ref'] = ResourceReference.to_string_reference(
pack=kwargs['pack'], name=kwargs['name'])
# Validate criteria
kwargs['criteria'] = dict(getattr(rule, 'criteria', {}))
validator.validate_criteria(kwargs['criteria'])
kwargs['action'] = ActionExecutionSpecDB(ref=rule.action['ref'],
parameters=rule.action.get(
'parameters', {}))
rule_type = dict(getattr(rule, 'type', {}))
if rule_type:
kwargs['type'] = RuleTypeSpecDB(ref=rule_type['ref'],
parameters=rule_type.get(
'parameters', {}))
kwargs['enabled'] = getattr(rule, 'enabled', False)
kwargs['tags'] = TagsHelper.to_model(getattr(rule, 'tags', []))
model = cls.model(**kwargs)
return model
'p1': 'v1',
'p2': 'preYYYpost',
'bool': True,
'int': 1,
'float': 0.8
})
MOCK_ACTION = ActionDB(id=bson.ObjectId(),
pack='wolfpack',
name='action-test-1.name')
MOCK_RULE_1 = RuleDB(
id=bson.ObjectId(),
pack='wolfpack',
name='some1',
trigger=reference.get_str_resource_ref_from_model(MOCK_TRIGGER),
criteria={},
action=ActionExecutionSpecDB(ref="somepack.someaction"))
MOCK_RULE_2 = RuleDB(
id=bson.ObjectId(),
pack='wolfpack',
name='some2',
trigger=reference.get_str_resource_ref_from_model(MOCK_TRIGGER),
criteria={},
action=ActionExecutionSpecDB(ref="somepack.someaction"))
@mock.patch.object(reference, 'get_model_by_resource_ref',
mock.MagicMock(return_value=MOCK_TRIGGER))
class FilterTest(DbTestCase):
def _setup_sample_rules(self):
rules = []
# Rules for st2.test.trigger1
RULE_1 = {
'enabled': True,
'name': 'st2.test.rule1',
'trigger': {
'type': 'dummy_pack_1.st2.test.trigger1'
},
'criteria': {
'k1': { # Missing prefix 'trigger'. This rule won't match.
'pattern': 't1_p_v',
'type': 'equals'
}
},
'action': {
'ref': 'sixpack.st2.test.action',
'parameters': {
'ip2': '{{rule.k1}}',
'ip1': '{{trigger.t1_p}}'
}
},
'id': '23',
'description': ''
}
rule_api = RuleAPI(**RULE_1)
rule_db = RuleAPI.to_model(rule_api)
trigger_api = TriggerAPI(**rule_api.trigger)
trigger_db = TriggerService.create_trigger_db(trigger_api)
trigger_ref = reference.get_str_resource_ref_from_model(trigger_db)
rule_db.trigger = trigger_ref
rule_db = Rule.add_or_update(rule_db)
rules.append(rule_db)
RULE_2 = { # Rule should match.
'enabled': True,
'name': 'st2.test.rule2',
'trigger': {
'type': 'dummy_pack_1.st2.test.trigger1'
},
'criteria': {
'trigger.k1': {
'pattern': 't1_p_v',
'type': 'equals'
}
},
'action': {
'ref': 'sixpack.st2.test.action',
'parameters': {
'ip2': '{{rule.k1}}',
'ip1': '{{trigger.t1_p}}'
}
},
'id': '23',
'description': ''
}
rule_api = RuleAPI(**RULE_2)
rule_db = RuleAPI.to_model(rule_api)
rule_db.trigger = trigger_ref
rule_db = Rule.add_or_update(rule_db)
rules.append(rule_db)
RULE_3 = {
'enabled': False, # Disabled rule shouldn't match.
'name': 'st2.test.rule3',
'trigger': {
'type': 'dummy_pack_1.st2.test.trigger1'
},
'criteria': {
'trigger.k1': {
'pattern': 't1_p_v',
'type': 'equals'
}
},
'action': {
'ref': 'sixpack.st2.test.action',
'parameters': {
'ip2': '{{rule.k1}}',
'ip1': '{{trigger.t1_p}}'
}
},
'id': '23',
'description': ''
}
rule_api = RuleAPI(**RULE_3)
rule_db = RuleAPI.to_model(rule_api)
rule_db.trigger = trigger_ref
rule_db = Rule.add_or_update(rule_db)
rules.append(rule_db)
# Rules for st2.test.trigger2
RULE_4 = {
'enabled': True,
'name': 'st2.test.rule4',
'trigger': {
'type': 'dummy_pack_1.st2.test.trigger2'
},
'criteria': {
'trigger.k1': {
'pattern': 't1_p_v',
'type': 'equals'
}
},
'action': {
'ref': 'sixpack.st2.test.action',
'parameters': {
'ip2': '{{rule.k1}}',
'ip1': '{{trigger.t1_p}}'
}
},
'id': '23',
'description': ''
}
rule_api = RuleAPI(**RULE_4)
rule_db = RuleAPI.to_model(rule_api)
trigger_api = TriggerAPI(**rule_api.trigger)
trigger_db = TriggerService.create_trigger_db(trigger_api)
trigger_ref = reference.get_str_resource_ref_from_model(trigger_db)
rule_db.trigger = trigger_ref
rule_db = Rule.add_or_update(rule_db)
rules.append(rule_db)
return rules
def test_triggered_execution(self):
docs = {
"trigger_type":
copy.deepcopy(fixture.ARTIFACTS["trigger_type"]),
"trigger":
copy.deepcopy(fixture.ARTIFACTS["trigger"]),
"rule":
copy.deepcopy(fixture.ARTIFACTS["rule"]),
"trigger_instance":
copy.deepcopy(fixture.ARTIFACTS["trigger_instance"]),
}
# Trigger an action execution.
trigger_type = TriggerType.add_or_update(
TriggerTypeAPI.to_model(TriggerTypeAPI(**docs["trigger_type"])))
trigger = Trigger.add_or_update(
TriggerAPI.to_model(TriggerAPI(**docs["trigger"])))
rule = RuleAPI.to_model(RuleAPI(**docs["rule"]))
rule.trigger = reference.get_str_resource_ref_from_model(trigger)
rule = Rule.add_or_update(rule)
trigger_instance = TriggerInstance.add_or_update(
TriggerInstanceAPI.to_model(
TriggerInstanceAPI(**docs["trigger_instance"])))
trace_service.add_or_update_given_trace_context(
trace_context={"trace_tag": "test_triggered_execution_trace"},
trigger_instances=[str(trigger_instance.id)],
)
enforcer = RuleEnforcer(trigger_instance, rule)
enforcer.enforce()
# Wait for the action execution to complete and then confirm outcome.
liveaction = LiveAction.get(
context__trigger_instance__id=str(trigger_instance.id))
self.assertIsNotNone(liveaction)
liveaction = self._wait_on_status(
liveaction, action_constants.LIVEACTION_STATUS_FAILED)
execution = self._get_action_execution(liveaction__id=str(
liveaction.id),
raise_exception=True)
self.assertDictEqual(execution.trigger,
vars(TriggerAPI.from_model(trigger)))
self.assertDictEqual(execution.trigger_type,
vars(TriggerTypeAPI.from_model(trigger_type)))
self.assertDictEqual(
execution.trigger_instance,
vars(TriggerInstanceAPI.from_model(trigger_instance)),
)
self.assertDictEqual(execution.rule, vars(RuleAPI.from_model(rule)))
action = action_utils.get_action_by_ref(liveaction.action)
self.assertDictEqual(execution.action,
vars(ActionAPI.from_model(action)))
runner = RunnerType.get_by_name(action.runner_type["name"])
self.assertDictEqual(execution.runner,
vars(RunnerTypeAPI.from_model(runner)))
liveaction = LiveAction.get_by_id(str(liveaction.id))
self.assertEqual(execution.start_timestamp, liveaction.start_timestamp)
# NOTE: Timestamp of liveaction and execution may be a bit different, depending on how long
# it takes to persist each object in the database
self.assertEqual(
execution.end_timestamp.replace(microsecond=0),
liveaction.end_timestamp.replace(microsecond=0),
)
self.assertEqual(execution.result, liveaction.result)
self.assertEqual(execution.status, liveaction.status)
self.assertEqual(execution.context, liveaction.context)
self.assertEqual(execution.liveaction["callback"], liveaction.callback)
self.assertEqual(execution.liveaction["action"], liveaction.action)
def _get_sample_rules(self):
rules = []
RULE_1 = {
'enabled': True,
'name': 'st2.test.rule1',
'trigger': {
'type': 'dummy_pack_1.st2.test.trigger1'
},
'criteria': {
'k1': { # Missing prefix 'trigger'. This rule won't match.
'pattern': 't1_p_v',
'type': 'equals'
}
},
'action': {
'ref': 'sixpack.st2.test.action',
'parameters': {
'ip2': '{{rule.k1}}',
'ip1': '{{trigger.t1_p}}'
}
},
'id': '23',
'description': ''
}
rule_api = RuleAPI(**RULE_1)
rule_db = RuleAPI.to_model(rule_api)
trigger_api = TriggerAPI(**rule_api.trigger)
trigger_db = TriggerService.create_trigger_db(trigger_api)
trigger_ref = reference.get_str_resource_ref_from_model(trigger_db)
rule_db.trigger = trigger_ref
rule_db = Rule.add_or_update(rule_db)
rules.append(rule_db)
RULE_2 = { # Rule should match.
'enabled': True,
'name': 'st2.test.rule2',
'trigger': {
'type': 'dummy_pack_1.st2.test.trigger1'
},
'criteria': {
'trigger.k1': {
'pattern': 't1_p_v',
'type': 'equals'
}
},
'action': {
'ref': 'sixpack.st2.test.action',
'parameters': {
'ip2': '{{rule.k1}}',
'ip1': '{{trigger.t1_p}}'
}
},
'id': '23',
'description': ''
}
rule_api = RuleAPI(**RULE_2)
rule_db = RuleAPI.to_model(rule_api)
rule_db.trigger = trigger_ref
rule_db = Rule.add_or_update(rule_db)
rules.append(rule_db)
RULE_3 = {
'enabled': False, # Disabled rule shouldn't match.
'name': 'st2.test.rule3',
'trigger': {
'type': 'dummy_pack_1.st2.test.trigger1'
},
'criteria': {
'trigger.k1': {
'pattern': 't1_p_v',
'type': 'equals'
}
},
'action': {
'ref': 'sixpack.st2.test.action',
'parameters': {
'ip2': '{{rule.k1}}',
'ip1': '{{trigger.t1_p}}'
}
},
'id': '23',
'description': ''
}
rule_api = RuleAPI(**RULE_3)
rule_db = RuleAPI.to_model(rule_api)
rule_db.trigger = trigger_ref
rule_db = Rule.add_or_update(rule_db)
rules.append(rule_db)
return rules
MOCK_TRIGGER = TriggerDB(pack='dummy_pack_1', name='trigger-test.name', type='system.test')
MOCK_TRIGGER_INSTANCE = TriggerInstanceDB(trigger=MOCK_TRIGGER.get_reference().ref,
occurrence_time=date_utils.get_datetime_utc_now(),
payload={
'p1': 'v1',
'p2': 'preYYYpost',
'bool': True,
'int': 1,
'float': 0.8})
MOCK_ACTION = ActionDB(id=bson.ObjectId(), pack='wolfpack', name='action-test-1.name')
MOCK_RULE_1 = RuleDB(id=bson.ObjectId(), pack='wolfpack', name='some1',
trigger=reference.get_str_resource_ref_from_model(MOCK_TRIGGER),
criteria={}, action=ActionExecutionSpecDB(ref="somepack.someaction"))
MOCK_RULE_2 = RuleDB(id=bson.ObjectId(), pack='wolfpack', name='some2',
trigger=reference.get_str_resource_ref_from_model(MOCK_TRIGGER),
criteria={}, action=ActionExecutionSpecDB(ref="somepack.someaction"))
@mock.patch.object(reference, 'get_model_by_resource_ref',
mock.MagicMock(return_value=MOCK_TRIGGER))
class FilterTest(DbTestCase):
def test_empty_criteria(self):
rule = MOCK_RULE_1
rule.criteria = {}
f = RuleFilter(MOCK_TRIGGER_INSTANCE, MOCK_TRIGGER, rule)
self.assertTrue(f.filter(), 'equals check should have failed.')
MOCK_TRIGGER_INSTANCE.trigger = reference.get_ref_from_model(MOCK_TRIGGER)
MOCK_TRIGGER_INSTANCE.payload = {}
MOCK_TRIGGER_INSTANCE.occurrence_time = datetime.datetime.utcnow()
MOCK_ACTION = ActionDB()
MOCK_ACTION.id = 'action-test-1.id'
MOCK_ACTION.name = 'action-test-1.name'
MOCK_ACTION_EXECUTION = ActionExecutionDB()
MOCK_ACTION_EXECUTION.id = 'actionexec-test-1.id'
MOCK_ACTION_EXECUTION.name = 'actionexec-test-1.name'
MOCK_ACTION_EXECUTION.status = 'scheduled'
MOCK_RULE_1 = RuleDB()
MOCK_RULE_1.id = 'rule-test-1'
MOCK_RULE_1.trigger = reference.get_str_resource_ref_from_model(MOCK_TRIGGER)
MOCK_RULE_1.criteria = {}
MOCK_RULE_1.action = ActionExecutionSpecDB()
MOCK_RULE_1.action.ref = reference.get_ref_from_model(MOCK_ACTION)
MOCK_RULE_1.enabled = True
MOCK_RULE_2 = RuleDB()
MOCK_RULE_2.id = 'rule-test-2'
MOCK_RULE_2.trigger = reference.get_str_resource_ref_from_model(MOCK_TRIGGER)
MOCK_RULE_2.criteria = {}
MOCK_RULE_2.action = ActionExecutionSpecDB()
MOCK_RULE_2.action.ref = reference.get_ref_from_model(MOCK_ACTION)
MOCK_RULE_2.enabled = True
class EnforceTest(unittest2.TestCase):
MOCK_TRIGGER_INSTANCE.trigger = reference.get_ref_from_model(MOCK_TRIGGER)
MOCK_TRIGGER_INSTANCE.payload = {}
MOCK_TRIGGER_INSTANCE.occurrence_time = datetime.datetime.utcnow()
MOCK_ACTION = ActionDB()
MOCK_ACTION.id = 'action-test-1.id'
MOCK_ACTION.name = 'action-test-1.name'
MOCK_ACTION_EXECUTION = ActionExecutionDB()
MOCK_ACTION_EXECUTION.id = 'actionexec-test-1.id'
MOCK_ACTION_EXECUTION.name = 'actionexec-test-1.name'
MOCK_ACTION_EXECUTION.status = 'scheduled'
MOCK_RULE_1 = RuleDB()
MOCK_RULE_1.id = 'rule-test-1'
MOCK_RULE_1.trigger = reference.get_str_resource_ref_from_model(MOCK_TRIGGER)
MOCK_RULE_1.criteria = {}
MOCK_RULE_1.action = ActionExecutionSpecDB()
MOCK_RULE_1.action.ref = reference.get_ref_from_model(MOCK_ACTION)
MOCK_RULE_1.enabled = True
MOCK_RULE_2 = RuleDB()
MOCK_RULE_2.id = 'rule-test-2'
MOCK_RULE_2.trigger = reference.get_str_resource_ref_from_model(MOCK_TRIGGER)
MOCK_RULE_2.criteria = {}
MOCK_RULE_2.action = ActionExecutionSpecDB()
MOCK_RULE_2.action.ref = reference.get_ref_from_model(MOCK_ACTION)
MOCK_RULE_2.enabled = True
class EnforceTest(unittest2.TestCase):
