def test_create_or_update_trigger_db_simple_triggers(self):
test_fixtures = {
'triggertypes': ['triggertype1.json']
}
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.json']['name'],
pack=triggertypes['triggertype1.json']['pack'])
trigger = {
'name': triggertypes['triggertype1.json']['name'],
'pack': triggertypes['triggertype1.json']['pack'],
'type': trigger_type_ref
}
trigger_service.create_or_update_trigger_db(trigger)
triggers = Trigger.get_all()
self.assertTrue(len(triggers) == 1, 'Only one trigger should be created.')
self.assertTrue(triggers[0]['name'] == triggertypes['triggertype1.json']['name'])
# Try adding duplicate
trigger_service.create_or_update_trigger_db(trigger)
triggers = Trigger.get_all()
self.assertTrue(len(triggers) == 1, 'Only one trigger should be present.')
self.assertTrue(triggers[0]['name'] == triggertypes['triggertype1.json']['name'])
def test_register_rules(self):
# Verify DB is empty at the beginning
self.assertEqual(len(Rule.get_all()), 0)
self.assertEqual(len(Trigger.get_all()), 0)
registrar = RulesRegistrar()
registrar.register_rules_from_packs(base_dirs=[PACKS_DIR])
# Verify modeles are created
rule_dbs = Rule.get_all()
trigger_dbs = Trigger.get_all()
self.assertEqual(len(rule_dbs), 2)
self.assertEqual(len(trigger_dbs), 1)
self.assertEqual(rule_dbs[0].name, 'sample.with_the_same_timer')
self.assertEqual(rule_dbs[1].name, 'sample.with_timer')
self.assertTrue(trigger_dbs[0].name is not None)
# Verify second register call updates existing models
registrar.register_rules_from_packs(base_dirs=[PACKS_DIR])
rule_dbs = Rule.get_all()
trigger_dbs = Trigger.get_all()
self.assertEqual(len(rule_dbs), 2)
self.assertEqual(len(trigger_dbs), 1)
def test_create_or_update_trigger_db_simple_triggers(self):
test_fixtures = {'triggertypes': ['triggertype1.json']}
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.json']['name'],
pack=triggertypes['triggertype1.json']['pack'])
trigger = {
'name': triggertypes['triggertype1.json']['name'],
'pack': triggertypes['triggertype1.json']['pack'],
'type': trigger_type_ref
}
trigger_service.create_or_update_trigger_db(trigger)
triggers = Trigger.get_all()
self.assertTrue(
len(triggers) == 1, 'Only one trigger should be created.')
self.assertTrue(
triggers[0]['name'] == triggertypes['triggertype1.json']['name'])
# Try adding duplicate
trigger_service.create_or_update_trigger_db(trigger)
triggers = Trigger.get_all()
self.assertTrue(
len(triggers) == 1, 'Only one trigger should be present.')
self.assertTrue(
triggers[0]['name'] == triggertypes['triggertype1.json']['name'])
def test_existing_rules_are_loaded_on_start(self):
# Assert that we dispatch message for every existing Trigger object
St2Timer._handle_create_trigger = Mock()
timer = St2Timer()
timer._scheduler = Mock()
timer._trigger_watcher.run = Mock()
# Verify there are no Trigger and TriggerType in the db wh:w
self.assertItemsEqual(Trigger.get_all(), [])
self.assertItemsEqual(TriggerType.get_all(), [])
# Add a dummy timer Trigger object
type = TIMER_TRIGGER_TYPES.keys()[0]
parameters = {'unit': 'seconds', 'delta': 1000}
trigger_db = TriggerDB(name='test_trigger_1', pack='dummy', type=type,
parameters=parameters)
trigger_db = Trigger.add_or_update(trigger_db)
# Verify object has been added
self.assertEqual(len(Trigger.get_all()), 1)
timer.start()
timer._trigger_watcher._load_thread.wait()
# Verify handlers are called
timer._handle_create_trigger.assert_called_with(trigger_db)
def setUp(self):
RUNNER_TYPE.id = None
RunnerType.add_or_update(RUNNER_TYPE)
ACTION.id = None
ACTION.runner_type = {'name': RUNNER_TYPE.name}
Action.add_or_update(ACTION)
TRIGGER.id = None
Trigger.add_or_update(TRIGGER)
def _delete_shadow_trigger(triggertype_db):
# shadow Trigger's have the same name as the shadowed TriggerType.
trigger_db = TriggerService.get_trigger_db(triggertype_db.name)
if not trigger_db:
LOG.warn('No shadow trigger found for %s. Will skip delete.', triggertype_db)
return
try:
Trigger.delete(trigger_db)
except Exception:
LOG.exception('Database delete encountered exception during delete of id="%s". ',
trigger_db.id)
LOG.audit('Trigger deleted. Trigger=%s', trigger_db)
def _delete_shadow_trigger(triggertype_db):
# shadow Trigger's have the same name as the shadowed TriggerType.
triggertype_ref = ResourceReference(name=triggertype_db.name, pack=triggertype_db.pack)
trigger_db = TriggerService.get_trigger_db_by_ref(triggertype_ref.ref)
if not trigger_db:
LOG.warn('No shadow trigger found for %s. Will skip delete.', triggertype_db)
return
try:
Trigger.delete(trigger_db)
except Exception:
LOG.exception('Database delete encountered exception during delete of id="%s". ',
trigger_db.id)
extra = {'trigger_db': trigger_db}
LOG.audit('Trigger deleted. Trigger.id=%s' % (trigger_db.id), extra=extra)
def _setup_sample_triggers(self, names=['st2.test.trigger1', 'st2.test.trigger2',
'st2.test.trigger3']):
trigger_dbs = []
for name in names:
trigtype = None
try:
trigtype = TriggerTypeDB()
trigtype.pack = 'dummy_pack_1'
trigtype.name = name
trigtype.description = ''
trigtype.payload_schema = {}
trigtype.parameters_schema = {}
try:
trigtype = TriggerType.get_by_name(name)
except:
trigtype = TriggerType.add_or_update(trigtype)
except NotUniqueError:
pass
created = TriggerDB()
created.name = name
created.pack = 'dummy_pack_1'
created.description = ''
created.type = trigtype.get_reference().ref
created.parameters = {}
created = Trigger.add_or_update(created)
trigger_dbs.append(created)
return trigger_dbs
def setUpClass(cls):
super(ReferenceTest, cls).setUpClass()
trigger = TriggerDB()
trigger.name = 'trigger-1'
trigger.pack = 'dummy_pack_1'
cls.__model = Trigger.add_or_update(trigger)
cls.__ref = {'id': str(cls.__model.id), 'name': cls.__model.name}
def __get_by_id(trigger_id):
try:
return Trigger.get_by_id(trigger_id)
except (ValueError, ValidationError):
LOG.exception('Database lookup for id="%s" resulted in exception.',
trigger_id)
abort(http_client.NOT_FOUND)
def create_or_update_trigger_db(trigger):
"""
Create a new TriggerDB model if one doesn't exist yet or update existing
one.
:param trigger: Trigger info.
:type trigger: ``dict``
"""
assert isinstance(trigger, dict)
existing_trigger_db = _get_trigger_db(trigger)
if existing_trigger_db:
is_update = True
else:
is_update = False
trigger_api = TriggerAPI(**trigger)
trigger_api.validate()
trigger_db = TriggerAPI.to_model(trigger_api)
if is_update:
trigger_db.id = existing_trigger_db.id
trigger_db = Trigger.add_or_update(trigger_db)
extra = {'trigger_db': trigger_db}
if is_update:
LOG.audit('Trigger updated. Trigger.id=%s' % (trigger_db.id), extra=extra)
else:
LOG.audit('Trigger created. Trigger.id=%s' % (trigger_db.id), extra=extra)
return trigger_db
def _setup_sample_trigger(self, name):
trigtype = TriggerTypeDB()
trigtype.name = name
trigtype.pack = 'dummy_pack_1'
trigtype.description = ''
trigtype.payload_schema = {}
trigtype.parameters_schema = {}
TriggerType.add_or_update(trigtype)
created = TriggerDB()
created.name = name
created.pack = 'dummy_pack_1'
created.description = ''
created.type = trigtype.get_reference().ref
created.parameters = {}
Trigger.add_or_update(created)
def create_or_update_trigger_db(trigger):
"""
Create a new TriggerDB model if one doesn't exist yet or update existing
one.
:param trigger: Trigger info.
:type trigger: ``dict``
"""
assert isinstance(trigger, dict)
existing_trigger_db = _get_trigger_db(trigger)
if existing_trigger_db:
is_update = True
else:
is_update = False
trigger_api = TriggerAPI(**trigger)
trigger_db = TriggerAPI.to_model(trigger_api)
if is_update:
trigger_db.id = existing_trigger_db.id
trigger_db = Trigger.add_or_update(trigger_db)
if is_update:
LOG.audit('Trigger updated. Trigger=%s', trigger_db)
else:
LOG.audit('Trigger created. Trigger=%s', trigger_db)
return trigger_db
def _setup_sample_trigger(self, name):
trigtype = TriggerTypeDB()
trigtype.name = name
trigtype.pack = 'dummy_pack_1'
trigtype.description = ''
trigtype.payload_schema = {}
trigtype.parameters_schema = {}
TriggerType.add_or_update(trigtype)
created = TriggerDB()
created.name = name
created.pack = 'dummy_pack_1'
created.description = ''
created.type = trigtype.get_reference().ref
created.parameters = {}
Trigger.add_or_update(created)
def _get_trigger_db_by_name_and_pack(name, pack):
try:
return Trigger.query(name=name, pack=pack).first()
except ValueError as e:
LOG.debug('Database lookup for name="%s",pack="%s" resulted ' +
'in exception : %s.', name, pack, e, exc_info=True)
return None
def _get_trigger_db(type=None, parameters=None):
try:
return Trigger.query(type=type,
parameters=parameters).first()
except ValueError as e:
LOG.debug('Database lookup for type="%s" parameters="%s" resulted ' +
'in exception : %s.', type, parameters, e, exc_info=True)
return None
def _create_save_triggertype():
created = TriggerTypeDB()
created.pack = 'dummy_pack_1'
created.name = 'triggertype-1'
created.description = ''
created.payload_schema = {}
created.parameters_schema = {}
return Trigger.add_or_update(created)
def _create_save_trigger(triggertype):
created = TriggerDB()
created.name = 'trigger-1'
created.pack = 'dummy_pack_1'
created.description = ''
created.type = triggertype.get_reference().ref
created.parameters = {}
return Trigger.add_or_update(created)
def _create_save_triggertype():
created = TriggerTypeDB()
created.pack = 'dummy_pack_1'
created.name = 'triggertype-1'
created.description = ''
created.payload_schema = {}
created.parameters_schema = {}
return Trigger.add_or_update(created)
def _create_save_trigger(triggertype):
created = TriggerDB()
created.name = 'trigger-1'
created.pack = 'dummy_pack_1'
created.description = ''
created.type = triggertype.get_reference().ref
created.parameters = {}
return Trigger.add_or_update(created)
def __get_by_name(trigger_name):
try:
return [Trigger.get_by_name(trigger_name)]
except ValueError as e:
LOG.debug(
'Database lookup for name="%s" resulted in exception : %s.',
trigger_name, e)
return []
def _get_trigger_instance_db(self):
if self._trigger_instance_file_path:
return self._get_trigger_instance_db_from_file(file_path=os.path.realpath(self._trigger_instance_file_path))
elif self._trigger_instance_id:
trigger_instance_db = TriggerInstance.get_by_id(self._trigger_instance_id)
trigger_db = Trigger.get_by_ref(trigger_instance_db.trigger)
return trigger_instance_db, trigger_db
raise ValueError("One of _trigger_instance_file_path or" "_trigger_instance_id should be specified.")
def setUpClass(cls):
super(ReferenceTest, cls).setUpClass()
trigger = TriggerDB()
trigger.name = 'trigger-1'
trigger.pack = 'dummy_pack_1'
cls.__model = Trigger.add_or_update(trigger)
cls.__ref = {'id': str(cls.__model.id),
'name': cls.__model.name}
def get_trigger_db_given_type_and_params(type=None, parameters=None):
try:
parameters = parameters or {}
trigger_db = Trigger.query(type=type,
parameters=parameters).first()
if not parameters and not trigger_db:
# We need to do double query because some TriggeDB objects without
# parameters have "parameters" attribute stored in the db and others
# don't
trigger_db = Trigger.query(type=type, parameters=None).first()
return trigger_db
except ValueError as e:
LOG.debug('Database lookup for type="%s" parameters="%s" resulted ' +
'in exception : %s.', type, parameters, e, exc_info=True)
return None
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 get_trigger_db_given_type_and_params(type=None, parameters=None):
try:
parameters = parameters or {}
trigger_db = Trigger.query(type=type,
parameters=parameters).first()
if not parameters and not trigger_db:
# We need to do double query because some TriggeDB objects without
# parameters have "parameters" attribute stored in the db and others
# don't
trigger_db = Trigger.query(type=type, parameters=None).first()
return trigger_db
except ValueError as e:
LOG.debug('Database lookup for type="%s" parameters="%s" resulted ' +
'in exception : %s.', type, parameters, e, exc_info=True)
return None
def test_trigger_lookup(self):
triggertype = ReactorModelTest._create_save_triggertype()
saved = ReactorModelTest._create_save_trigger(triggertype)
retrievedtriggers = Trigger.query(name=saved.name)
self.assertEqual(1, len(retrievedtriggers), 'No triggers found.')
for retrievedtrigger in retrievedtriggers:
self.assertEqual(saved.id, retrievedtrigger.id,
'Incorrect trigger returned.')
ReactorModelTest._delete([saved, triggertype])
def test_trigger_lookup(self):
triggertype = ReactorModelTest._create_save_triggertype()
saved = ReactorModelTest._create_save_trigger(triggertype)
retrievedtriggers = Trigger.query(name=saved.name)
self.assertEqual(1, len(retrievedtriggers), 'No triggers found.')
for retrievedtrigger in retrievedtriggers:
self.assertEqual(saved.id, retrievedtrigger.id,
'Incorrect trigger returned.')
ReactorModelTest._delete([saved, triggertype])
def delete(self, trigger_id):
"""
Delete a trigger.
Handles requests:
DELETE /triggers/1
"""
LOG.info('DELETE /triggers/ with id=%s', trigger_id)
trigger_db = TriggerController.__get_by_id(trigger_id)
try:
Trigger.delete(trigger_db)
except Exception as e:
LOG.exception('Database delete encountered exception during delete of id="%s". ',
trigger_id)
abort(http_client.INTERNAL_SERVER_ERROR, str(e))
return
LOG.audit('Trigger deleted. Trigger=%s', trigger_db)
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 _get_trigger_instance_db(self):
if self._trigger_instance_file_path:
return self._get_trigger_instance_db_from_file(
file_path=os.path.realpath(self._trigger_instance_file_path))
elif self._trigger_instance_id:
trigger_instance_db = TriggerInstance.get_by_id(self._trigger_instance_id)
trigger_db = Trigger.get_by_ref(trigger_instance_db.trigger)
return trigger_instance_db, trigger_db
raise ValueError('One of _trigger_instance_file_path or'
'_trigger_instance_id should be specified.')
def get_trigger_db_by_ref(ref):
"""
Returns the trigger object from db given a string ref.
:param ref: Reference to the trigger db object.
:type ref: ``str``
:rtype trigger_type: ``object``
"""
return Trigger.get_by_ref(ref)
def test_trigger_crud(self):
triggertype = ReactorModelTest._create_save_triggertype()
saved = ReactorModelTest._create_save_trigger(triggertype)
retrieved = Trigger.get_by_id(saved.id)
self.assertEqual(saved.name, retrieved.name,
'Same trigger was not returned.')
# test update
self.assertEqual(retrieved.description, '')
retrieved.description = DUMMY_DESCRIPTION
saved = Trigger.add_or_update(retrieved)
retrieved = Trigger.get_by_id(saved.id)
self.assertEqual(retrieved.description, DUMMY_DESCRIPTION, 'Update to trigger failed.')
# cleanup
ReactorModelTest._delete([retrieved, triggertype])
try:
retrieved = Trigger.get_by_id(saved.id)
except ValueError:
retrieved = None
self.assertIsNone(retrieved, 'managed to retrieve after failure.')
def _delete_shadow_trigger(triggertype_db):
# shadow Trigger's have the same name as the shadowed TriggerType.
triggertype_ref = ResourceReference(name=triggertype_db.name,
pack=triggertype_db.pack)
trigger_db = TriggerService.get_trigger_db_by_ref(triggertype_ref.ref)
if not trigger_db:
LOG.warn('No shadow trigger found for %s. Will skip delete.',
triggertype_db)
return
try:
Trigger.delete(trigger_db)
except Exception:
LOG.exception(
'Database delete encountered exception during delete of id="%s". ',
trigger_db.id)
extra = {'trigger_db': trigger_db}
LOG.audit('Trigger deleted. Trigger.id=%s' % (trigger_db.id),
extra=extra)
def get_trigger_db_by_ref(ref):
"""
Returns the trigger object from db given a string ref.
:param ref: Reference to the trigger db object.
:type ref: ``str``
:rtype trigger_type: ``object``
"""
return Trigger.get_by_ref(ref)
def create_trigger_db(trigger):
trigger_api = trigger
if isinstance(trigger, dict):
trigger_api = TriggerAPI(**trigger)
trigger_db = get_trigger_db(trigger_api)
if not trigger_db:
trigger_db = TriggerAPI.to_model(trigger_api)
LOG.debug('verified trigger and formulated TriggerDB=%s', trigger_db)
trigger_db = Trigger.add_or_update(trigger_db)
return trigger_db
def create_trigger_db(trigger_api):
# TODO: This is used only in trigger API controller. We should get rid of this.
trigger_ref = ResourceReference.to_string_reference(name=trigger_api.name,
pack=trigger_api.pack)
trigger_db = get_trigger_db_by_ref(trigger_ref)
if not trigger_db:
trigger_db = TriggerAPI.to_model(trigger_api)
LOG.debug('Verified trigger and formulated TriggerDB=%s', trigger_db)
trigger_db = Trigger.add_or_update(trigger_db)
return trigger_db
def get_all(self, **kw):
"""
List all triggers.
Handles requests:
GET /triggers/
"""
trigger_dbs = Trigger.get_all(**kw)
trigger_apis = [TriggerAPI.from_model(trigger_db) for trigger_db in trigger_dbs]
return trigger_apis
def test_trigger_crud(self):
triggertype = ReactorModelTest._create_save_triggertype()
saved = ReactorModelTest._create_save_trigger(triggertype)
retrieved = Trigger.get_by_id(saved.id)
self.assertEqual(saved.name, retrieved.name,
'Same trigger was not returned.')
# test update
self.assertEqual(retrieved.description, '')
retrieved.description = DUMMY_DESCRIPTION
saved = Trigger.add_or_update(retrieved)
retrieved = Trigger.get_by_id(saved.id)
self.assertEqual(retrieved.description, DUMMY_DESCRIPTION, 'Update to trigger failed.')
# cleanup
ReactorModelTest._delete([retrieved, triggertype])
try:
retrieved = Trigger.get_by_id(saved.id)
except ValueError:
retrieved = None
self.assertIsNone(retrieved, 'managed to retrieve after failure.')
def create_trigger_db(trigger_api):
# TODO: This is used only in trigger API controller. We should get rid of this.
trigger_ref = ResourceReference.to_string_reference(name=trigger_api.name,
pack=trigger_api.pack)
trigger_db = get_trigger_db_by_ref(trigger_ref)
if not trigger_db:
trigger_db = TriggerAPI.to_model(trigger_api)
LOG.debug('Verified trigger and formulated TriggerDB=%s', trigger_db)
trigger_db = Trigger.add_or_update(trigger_db)
return trigger_db
def get_all(self, **kw):
"""
List all triggers.
Handles requests:
GET /triggers/
"""
LOG.info('GET all /triggers/ with filters=%s', kw)
trigger_dbs = Trigger.get_all(**kw)
trigger_apis = [TriggerAPI.from_model(trigger_db) for trigger_db in trigger_dbs]
return trigger_apis
def get_all(self, **kw):
"""
List all triggers.
Handles requests:
GET /triggers/
"""
trigger_dbs = Trigger.get_all(**kw)
trigger_apis = [
TriggerAPI.from_model(trigger_db) for trigger_db in trigger_dbs
]
return trigger_apis
def test_create_trigger_db_from_rule_duplicate(self):
test_fixtures = {
'rules': ['cron_timer_rule_1.json', 'cron_timer_rule_2.json']
}
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.json']))
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.json']))
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.json']['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 put(self, trigger_id, trigger):
trigger_db = TriggerController.__get_by_id(trigger_id)
try:
if trigger.id is not None and trigger.id is not '' and trigger.id != trigger_id:
LOG.warning('Discarding mismatched id=%s found in payload and using uri_id=%s.',
trigger.id, trigger_id)
trigger_db = TriggerAPI.to_model(trigger)
trigger_db.id = trigger_id
trigger_db = Trigger.add_or_update(trigger_db)
except (ValidationError, ValueError) as e:
LOG.exception('Validation failed for trigger data=%s', trigger)
abort(http_client.BAD_REQUEST, str(e))
return
extra = {'old_trigger_db': trigger, 'new_trigger_db': trigger_db}
LOG.audit('Trigger updated. Trigger.id=%s' % (trigger.id), extra=extra)
trigger_api = TriggerAPI.from_model(trigger_db)
return trigger_api
def put(self, trigger_id, trigger):
trigger_db = TriggerController.__get_by_id(trigger_id)
try:
if trigger.id is not None and trigger.id is not '' and trigger.id != trigger_id:
LOG.warning(
'Discarding mismatched id=%s found in payload and using uri_id=%s.',
trigger.id, trigger_id)
trigger_db = TriggerAPI.to_model(trigger)
trigger_db.id = trigger_id
trigger_db = Trigger.add_or_update(trigger_db)
except (ValidationError, ValueError) as e:
LOG.exception('Validation failed for trigger data=%s', trigger)
abort(http_client.BAD_REQUEST, str(e))
return
extra = {'old_trigger_db': trigger, 'new_trigger_db': trigger_db}
LOG.audit('Trigger updated. Trigger.id=%s' % (trigger.id), extra=extra)
trigger_api = TriggerAPI.from_model(trigger_db)
return trigger_api
def put(self, trigger_id, trigger):
LOG.info('PUT /triggers/ with trigger id=%s and data=%s', trigger_id, trigger)
trigger_db = TriggerController.__get_by_id(trigger_id)
try:
if trigger.id is not None and trigger.id is not '' and trigger.id != trigger_id:
LOG.warning('Discarding mismatched id=%s found in payload and using uri_id=%s.',
trigger.id, trigger_id)
trigger_db = TriggerAPI.to_model(trigger)
trigger_db.id = trigger_id
trigger_db = Trigger.add_or_update(trigger_db)
except (ValidationError, ValueError) as e:
LOG.exception('Validation failed for trigger data=%s', trigger)
abort(http_client.BAD_REQUEST, str(e))
return
LOG.audit('Trigger updated. Trigger=%s and original Trigger=%s.', trigger, trigger_db)
trigger_api = TriggerAPI.from_model(trigger_db)
LOG.debug('PUT /triggers/ client_result=%s', trigger_api)
return trigger_api
def test_create_trigger_db_from_rule_duplicate(self):
test_fixtures = {
'rules': ['cron_timer_rule_1.json', 'cron_timer_rule_2.json']
}
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.json']))
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.json']))
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.json']['trigger']['parameters'])
def test_add_trigger_type_no_params(self):
# Trigger type with no params should create a trigger with same name as trigger type.
trig_type = {
'name': 'myawesometriggertype',
'pack': 'dummy_pack_1',
'description': 'Words cannot describe how awesome I am.',
'parameters_schema': {},
'payload_schema': {}
}
trigtype_dbs = container_utils.add_trigger_models(trigger_types=[trig_type])
trigger_type, trigger = trigtype_dbs[0]
trigtype_db = TriggerType.get_by_id(trigger_type.id)
self.assertEqual(trigtype_db.pack, 'dummy_pack_1')
self.assertEqual(trigtype_db.name, trig_type.get('name'))
self.assertTrue(trigger is not None)
self.assertEqual(trigger.name, trigtype_db.name)
# Add duplicate
trigtype_dbs = container_utils.add_trigger_models(trigger_types=[trig_type])
triggers = Trigger.get_all()
self.assertTrue(len(triggers) == 1)
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)))
