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 _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 __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 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 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 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 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)))