def test_exception_thrown_when_rule_creation_no_trigger_yes_triggertype(self):
test_fixtures = {
'triggertypes': ['triggertype1.yaml']
}
loader = FixturesLoader()
fixtures = loader.save_fixtures_to_db(fixtures_pack='generic', fixtures_dict=test_fixtures)
triggertypes = fixtures['triggertypes']
trigger_type_ref = ResourceReference.to_string_reference(
name=triggertypes['triggertype1.yaml']['name'],
pack=triggertypes['triggertype1.yaml']['pack'])
rule = {
'name': 'fancyrule',
'trigger': {
'type': trigger_type_ref
},
'criteria': {
},
'action': {
'ref': 'core.local',
'parameters': {
'cmd': 'date'
}
}
}
rule_api = RuleAPI(**rule)
self.assertRaises(TriggerDoesNotExistException,
trigger_service.create_trigger_db_from_rule, rule_api)
def _register_rules_from_pack(self, pack, rules):
registered_count = 0
for rule in rules:
LOG.debug('Loading rule from %s.', rule)
try:
content = self._meta_loader.load(rule)
rule_api = RuleAPI(**content)
rule_db = RuleAPI.to_model(rule_api)
try:
rule_db.id = Rule.get_by_name(rule_api.name).id
except ValueError:
LOG.debug('Rule %s not found. Creating new one.', rule)
try:
rule_db = Rule.add_or_update(rule_db)
extra = {'rule_db': rule_db}
LOG.audit('Rule updated. Rule %s from %s.', rule_db, rule, extra=extra)
except Exception:
LOG.exception('Failed to create rule %s.', rule_api.name)
except:
LOG.exception('Failed registering rule from %s.', rule)
else:
registered_count += 1
return registered_count
def test_exception_thrown_when_rule_creation_no_trigger_yes_triggertype(
self):
test_fixtures = {"triggertypes": ["triggertype1.yaml"]}
loader = FixturesLoader()
fixtures = loader.save_fixtures_to_db(fixtures_pack="generic",
fixtures_dict=test_fixtures)
triggertypes = fixtures["triggertypes"]
trigger_type_ref = ResourceReference.to_string_reference(
name=triggertypes["triggertype1.yaml"]["name"],
pack=triggertypes["triggertype1.yaml"]["pack"],
)
rule = {
"name": "fancyrule",
"trigger": {
"type": trigger_type_ref
},
"criteria": {},
"action": {
"ref": "core.local",
"parameters": {
"cmd": "date"
}
},
}
rule_api = RuleAPI(**rule)
self.assertRaises(
TriggerDoesNotExistException,
trigger_service.create_trigger_db_from_rule,
rule_api,
)
def test_create_trigger_db_from_rule_duplicate(self):
test_fixtures = {
'rules': ['cron_timer_rule_1.yaml', 'cron_timer_rule_2.yaml']
}
loader = FixturesLoader()
fixtures = loader.load_fixtures(fixtures_pack='generic', fixtures_dict=test_fixtures)
rules = fixtures['rules']
trigger_db_ret_1 = trigger_service.create_trigger_db_from_rule(
RuleAPI(**rules['cron_timer_rule_1.yaml']))
self.assertTrue(trigger_db_ret_1 is not None)
trigger_db_ret_2 = trigger_service.create_trigger_db_from_rule(
RuleAPI(**rules['cron_timer_rule_2.yaml']))
self.assertTrue(trigger_db_ret_2 is not None)
self.assertEqual(trigger_db_ret_1, trigger_db_ret_2, 'Should reuse same trigger.')
trigger_db = Trigger.get_by_id(trigger_db_ret_1.id)
self.assertDictEqual(trigger_db.parameters,
rules['cron_timer_rule_1.yaml']['trigger']['parameters'])
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_create_trigger_db_from_rule_duplicate(self):
test_fixtures = {
"rules": ["cron_timer_rule_1.yaml", "cron_timer_rule_2.yaml"]
}
loader = FixturesLoader()
fixtures = loader.load_fixtures(fixtures_pack="generic",
fixtures_dict=test_fixtures)
rules = fixtures["rules"]
trigger_db_ret_1 = trigger_service.create_trigger_db_from_rule(
RuleAPI(**rules["cron_timer_rule_1.yaml"]))
self.assertIsNotNone(trigger_db_ret_1)
trigger_db_ret_2 = trigger_service.create_trigger_db_from_rule(
RuleAPI(**rules["cron_timer_rule_2.yaml"]))
self.assertIsNotNone(trigger_db_ret_2)
self.assertEqual(trigger_db_ret_1, trigger_db_ret_2,
"Should reuse same trigger.")
trigger_db = Trigger.get_by_id(trigger_db_ret_1.id)
self.assertDictEqual(
trigger_db.parameters,
rules["cron_timer_rule_1.yaml"]["trigger"]["parameters"],
)
def _setup_sample_rules(self):
rules = []
# Rules for st2.test.trigger1
RULE_1 = {
'enabled': True,
'name': 'st2.test.rule1',
'pack': 'sixpack',
'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)
rule_db = Rule.add_or_update(rule_db)
rules.append(rule_db)
RULE_2 = { # Rule should match.
'enabled': True,
'name': 'st2.test.rule2',
'pack': 'sixpack',
'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 = Rule.add_or_update(rule_db)
rules.append(rule_db)
RULE_3 = {
'enabled': False, # Disabled rule shouldn't match.
'name': 'st2.test.rule3',
'pack': 'sixpack',
'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 = Rule.add_or_update(rule_db)
rules.append(rule_db)
# Rules for st2.test.trigger2
RULE_4 = {
'enabled': True,
'name': 'st2.test.rule4',
'pack': 'sixpack',
'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)
rule_db = Rule.add_or_update(rule_db)
rules.append(rule_db)
return rules
def _register_rules_from_pack(self, pack, rules):
registered_count = 0
# TODO: Refactor this monstrosity
for rule in rules:
LOG.debug('Loading rule from %s.', rule)
try:
content = self._meta_loader.load(rule)
pack_field = content.get('pack', None)
if not pack_field:
content['pack'] = pack
pack_field = pack
if pack_field != pack:
raise Exception(
'Model is in pack "%s" but field "pack" is different: %s'
% (pack, pack_field))
rule_api = RuleAPI(**content)
rule_api.validate()
rule_db = RuleAPI.to_model(rule_api)
# Migration from rule without pack to rule with pack.
# There might be a rule with same name but in pack `default`
# generated in migration script. In this case, we want to
# delete so we don't have duplicates.
if pack_field != DEFAULT_PACK_NAME:
try:
rule_ref = ResourceReference.to_string_reference(
name=content['name'], pack=DEFAULT_PACK_NAME)
LOG.debug('Looking for rule %s in pack %s',
content['name'], DEFAULT_PACK_NAME)
existing = Rule.get_by_ref(rule_ref)
LOG.debug('Existing = %s', existing)
if existing:
LOG.debug(
'Found rule in pack default: %s; Deleting.',
rule_ref)
Rule.delete(existing)
except:
LOG.exception('Exception deleting rule from %s pack.',
DEFAULT_PACK_NAME)
try:
rule_ref = ResourceReference.to_string_reference(
name=content['name'], pack=content['pack'])
existing = Rule.get_by_ref(rule_ref)
if existing:
rule_db.id = existing.id
LOG.debug('Found existing rule: %s with id: %s',
rule_ref, existing.id)
except StackStormDBObjectNotFoundError:
LOG.debug('Rule %s not found. Creating new one.', rule)
try:
rule_db = Rule.add_or_update(rule_db)
increment_trigger_ref_count(rule_api=rule_api)
extra = {'rule_db': rule_db}
LOG.audit('Rule updated. Rule %s from %s.',
rule_db,
rule,
extra=extra)
except Exception:
LOG.exception('Failed to create rule %s.', rule_api.name)
# If there was an existing rule then the ref count was updated in
# to_model so it needs to be adjusted down here. Also, update could
# lead to removal of a Trigger so now is a good time for book-keeping.
if existing:
cleanup_trigger_db_for_rule(existing)
except Exception as e:
if self._fail_on_failure:
raise e
LOG.exception('Failed registering rule from %s.', rule)
else:
registered_count += 1
return registered_count
def _get_sample_rules(self):
if self.rules:
# Make sure rules are created only once
return self.rules
RULE_1 = {
'enabled': True,
'name': 'st2.test.rule1',
'pack': 'yoyohoneysingh',
'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)
rule_db = Rule.add_or_update(rule_db)
self.rules.append(rule_db)
RULE_2 = { # Rule should match.
'enabled': True,
'name': 'st2.test.rule2',
'pack': 'yoyohoneysingh',
'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 = Rule.add_or_update(rule_db)
self.rules.append(rule_db)
RULE_3 = {
'enabled': False, # Disabled rule shouldn't match.
'name': 'st2.test.rule3',
'pack': 'yoyohoneysingh',
'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 = Rule.add_or_update(rule_db)
self.rules.append(rule_db)
return self.rules
def _setup_sample_rule(self, rule):
rule_api = RuleAPI(**rule)
rule_db = RuleAPI.to_model(rule_api)
rule_db = Rule.add_or_update(rule_db)
return rule_db
def _setup_sample_rules(self):
rules = []
# Rules for st2.test.trigger1
RULE_1 = {
"enabled": True,
"name": "st2.test.rule1",
"pack": "sixpack",
"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)
rule_db = Rule.add_or_update(rule_db)
rules.append(rule_db)
RULE_2 = { # Rule should match.
"enabled": True,
"name": "st2.test.rule2",
"pack": "sixpack",
"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 = Rule.add_or_update(rule_db)
rules.append(rule_db)
RULE_3 = {
"enabled": False, # Disabled rule shouldn't match.
"name": "st2.test.rule3",
"pack": "sixpack",
"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 = Rule.add_or_update(rule_db)
rules.append(rule_db)
# Rules for st2.test.trigger2
RULE_4 = {
"enabled": True,
"name": "st2.test.rule4",
"pack": "sixpack",
"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)
rule_db = Rule.add_or_update(rule_db)
rules.append(rule_db)
return rules
def _register_rules_from_pack(self, pack, rules):
registered_count = 0
overridden_count = 0
# TODO: Refactor this monstrosity
for rule in rules:
LOG.debug("Loading rule from %s.", rule)
try:
content = self._meta_loader.load(rule)
pack_field = content.get("pack", None)
if not pack_field:
content["pack"] = pack
pack_field = pack
if pack_field != pack:
raise Exception(
'Model is in pack "%s" but field "pack" is different: %s'
% (pack, pack_field))
metadata_file = content_utils.get_relative_path_to_pack_file(
pack_ref=pack, file_path=rule, use_pack_cache=True)
content["metadata_file"] = metadata_file
# Pass override information
altered = self._override_loader.override(
pack, "rules", content)
rule_api = RuleAPI(**content)
rule_api.validate()
rule_db = RuleAPI.to_model(rule_api)
# Migration from rule without pack to rule with pack.
# There might be a rule with same name but in pack `default`
# generated in migration script. In this case, we want to
# delete so we don't have duplicates.
if pack_field != DEFAULT_PACK_NAME:
try:
rule_ref = ResourceReference.to_string_reference(
name=content["name"], pack=DEFAULT_PACK_NAME)
LOG.debug(
"Looking for rule %s in pack %s",
content["name"],
DEFAULT_PACK_NAME,
)
existing = Rule.get_by_ref(rule_ref)
LOG.debug("Existing = %s", existing)
if existing:
LOG.debug(
"Found rule in pack default: %s; Deleting.",
rule_ref)
Rule.delete(existing)
except:
LOG.exception("Exception deleting rule from %s pack.",
DEFAULT_PACK_NAME)
try:
rule_ref = ResourceReference.to_string_reference(
name=content["name"], pack=content["pack"])
existing = Rule.get_by_ref(rule_ref)
if existing:
rule_db.id = existing.id
LOG.debug("Found existing rule: %s with id: %s",
rule_ref, existing.id)
except StackStormDBObjectNotFoundError:
LOG.debug("Rule %s not found. Creating new one.", rule)
try:
rule_db = Rule.add_or_update(rule_db)
increment_trigger_ref_count(rule_api=rule_api)
extra = {"rule_db": rule_db}
LOG.audit("Rule updated. Rule %s from %s.",
rule_db,
rule,
extra=extra)
except Exception:
LOG.exception("Failed to create rule %s.", rule_api.name)
# If there was an existing rule then the ref count was updated in
# to_model so it needs to be adjusted down here. Also, update could
# lead to removal of a Trigger so now is a good time for book-keeping.
if existing:
cleanup_trigger_db_for_rule(existing)
except Exception as e:
if self._fail_on_failure:
msg = 'Failed to register rule "%s" from pack "%s": %s' % (
rule,
pack,
six.text_type(e),
)
raise ValueError(msg)
LOG.exception("Failed registering rule from %s.", rule)
else:
registered_count += 1
if altered:
overridden_count += 1
return registered_count, overridden_count
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 _register_rules_from_pack(self, pack, rules):
registered_count = 0
for rule in rules:
LOG.debug('Loading rule from %s.', rule)
try:
content = self._meta_loader.load(rule)
pack_field = content.get('pack', None)
if not pack_field:
content['pack'] = pack
pack_field = pack
if pack_field != pack:
raise Exception(
'Model is in pack "%s" but field "pack" is different: %s'
% (pack, pack_field))
rule_api = RuleAPI(**content)
rule_api.validate()
rule_db = RuleAPI.to_model(rule_api)
# Migration from rule without pack to rule with pack.
# There might be a rule with same name but in pack `default`
# generated in migration script. In this case, we want to
# delete so we don't have duplicates.
if pack_field != DEFAULT_PACK_NAME:
try:
rule_ref = ResourceReference.to_string_reference(
name=content['name'], pack=DEFAULT_PACK_NAME)
LOG.debug('Looking for rule %s in pack %s',
content['name'], DEFAULT_PACK_NAME)
existing = Rule.get_by_ref(rule_ref)
LOG.debug('Existing = %s', existing)
if existing:
LOG.debug(
'Found rule in pack default: %s; Deleting.',
rule_ref)
Rule.delete(existing)
except:
LOG.exception('Exception deleting rule from %s pack.',
DEFAULT_PACK_NAME)
try:
rule_ref = ResourceReference.to_string_reference(
name=content['name'], pack=content['pack'])
existing = Rule.get_by_ref(rule_ref)
if existing:
rule_db.id = existing.id
LOG.debug('Found existing rule: %s with id: %s',
rule_ref, existing.id)
except ValueError:
LOG.debug('Rule %s not found. Creating new one.', rule)
try:
rule_db = Rule.add_or_update(rule_db)
extra = {'rule_db': rule_db}
LOG.audit('Rule updated. Rule %s from %s.',
rule_db,
rule,
extra=extra)
except Exception:
LOG.exception('Failed to create rule %s.', rule_api.name)
except:
LOG.exception('Failed registering rule from %s.', rule)
else:
registered_count += 1
return registered_count
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
