def test_existing_rules_are_loaded_on_start(self): # Assert that we dispatch message for every existing Trigger object St2Timer._handle_create_trigger = mock.Mock() timer = St2Timer() timer._scheduler = mock.Mock() timer._trigger_watcher.run = mock.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(id=bson.ObjectId(), 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 test_create_or_update_trigger_db_simple_triggers(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']) trigger = { 'name': triggertypes['triggertype1.yaml']['name'], 'pack': triggertypes['triggertype1.yaml']['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.yaml']['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.yaml']['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_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_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 _setup_sample_trigger(self, name): trigtype = TriggerTypeDB(name=name, pack='dummy_pack_1', payload_schema={}, parameters_schema={}) TriggerType.add_or_update(trigtype) created = TriggerDB(name=name, pack='dummy_pack_1', type=trigtype.get_reference().ref, parameters={}) Trigger.add_or_update(created)
def cleanup_trigger_db_for_rule(rule_db): # rule.trigger is actually trigger_db ref. existing_trigger_db = get_trigger_db_by_ref(rule_db.trigger) if not existing_trigger_db or not existing_trigger_db.parameters: # nothing to be done here so moving on. LOG.debug('ref_count decrement for %s not required.', existing_trigger_db) return Trigger.update(existing_trigger_db, dec__ref_count=1) Trigger.delete_if_unreferenced(existing_trigger_db)
def get_trigger_db_given_type_and_params(type=None, parameters=None): try: parameters = parameters or {} trigger_dbs = Trigger.query(type=type, parameters=parameters) trigger_db = trigger_dbs[0] if len(trigger_dbs) > 0 else None # NOTE: This is a work-around which we might be able to remove once we upgrade # pymongo and mongoengine # Work around for cron-timer when in some scenarios finding an object fails when Python # value types are unicode :/ is_cron_trigger = type == CRON_TIMER_TRIGGER_REF has_parameters = bool(parameters) if not trigger_db and six.PY2 and is_cron_trigger and has_parameters: non_unicode_literal_parameters = {} for key, value in six.iteritems(parameters): key = key.encode("utf-8") if isinstance(value, six.text_type): # We only encode unicode to str value = value.encode("utf-8") non_unicode_literal_parameters[key] = value parameters = non_unicode_literal_parameters trigger_dbs = Trigger.query(type=type, parameters=non_unicode_literal_parameters).no_cache() # Note: We need to directly access the object, using len or accessing the query set # twice won't work - there seems to bug a bug with cursor where accessing it twice # will throw an exception try: trigger_db = trigger_dbs[0] except IndexError: trigger_db = None 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 StackStormDBObjectNotFoundError as e: LOG.debug( 'Database lookup for type="%s" parameters="%s" resulted ' + "in exception : %s.", type, parameters, e, exc_info=True, ) return None
def increment_trigger_ref_count(rule_api): """ Given the rule figures out the TriggerType with parameter and increments reference count on the appropriate Trigger. :param rule_api: Rule object used to infer the Trigger. :type rule_api: ``RuleApi`` """ trigger_dict = _get_trigger_dict_given_rule(rule_api) # Special reference counting for trigger with parameters. if trigger_dict.get('parameters', None): trigger_db = _get_trigger_db(trigger_dict) Trigger.update(trigger_db, inc__ref_count=1)
def test_get_trigger_db_given_type_and_params(self): # Add dummy triggers trigger_1 = TriggerDB(pack='testpack', name='testtrigger1', type='testpack.testtrigger1') trigger_2 = TriggerDB(pack='testpack', name='testtrigger2', type='testpack.testtrigger2') trigger_3 = TriggerDB(pack='testpack', name='testtrigger3', type='testpack.testtrigger3') trigger_4 = TriggerDB(pack='testpack', name='testtrigger4', type='testpack.testtrigger4', parameters={'ponies': 'unicorn'}) Trigger.add_or_update(trigger_1) Trigger.add_or_update(trigger_2) Trigger.add_or_update(trigger_3) Trigger.add_or_update(trigger_4) # Trigger with no parameters, parameters={} in db trigger_db = trigger_service.get_trigger_db_given_type_and_params(type=trigger_1.type, parameters={}) self.assertEqual(trigger_db, trigger_1) trigger_db = trigger_service.get_trigger_db_given_type_and_params(type=trigger_1.type, parameters=None) self.assertEqual(trigger_db, trigger_1) trigger_db = trigger_service.get_trigger_db_given_type_and_params(type=trigger_1.type, parameters={'fo': 'bar'}) self.assertEqual(trigger_db, None) # Trigger with no parameters, no parameters attribute in the db trigger_db = trigger_service.get_trigger_db_given_type_and_params(type=trigger_2.type, parameters={}) self.assertEqual(trigger_db, trigger_2) trigger_db = trigger_service.get_trigger_db_given_type_and_params(type=trigger_2.type, parameters=None) self.assertEqual(trigger_db, trigger_2) trigger_db = trigger_service.get_trigger_db_given_type_and_params(type=trigger_2.type, parameters={'fo': 'bar'}) self.assertEqual(trigger_db, None) trigger_db = trigger_service.get_trigger_db_given_type_and_params(type=trigger_3.type, parameters={}) self.assertEqual(trigger_db, trigger_3) trigger_db = trigger_service.get_trigger_db_given_type_and_params(type=trigger_3.type, parameters=None) self.assertEqual(trigger_db, trigger_3) # Trigger with parameters trigger_db = trigger_service.get_trigger_db_given_type_and_params( type=trigger_4.type, parameters=trigger_4.parameters) self.assertEqual(trigger_db, trigger_4) trigger_db = trigger_service.get_trigger_db_given_type_and_params(type=trigger_4.type, parameters=None) self.assertEqual(trigger_db, None)
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', 'st2.test.trigger4']): trigger_dbs = [] for name in names: trigtype = None try: trigtype = TriggerTypeDB(pack='dummy_pack_1', name=name, description='', payload_schema={}, parameters_schema={}) try: trigtype = TriggerType.get_by_name(name) except: trigtype = TriggerType.add_or_update(trigtype) except NotUniqueError: pass created = TriggerDB(pack='dummy_pack_1', name=name, description='', type=trigtype.get_reference().ref) if name in ['st2.test.trigger4']: created.parameters = {'url': 'sample'} else: created.parameters = {} created = Trigger.add_or_update(created) trigger_dbs.append(created) return trigger_dbs
def get_all(self, exclude_attributes=None, include_attributes=None, sort=None, offset=0, limit=None, requester_user=None, **raw_filters): """ List all triggerinstances. Handles requests: GET /triggerinstances/ """ # If trigger_type filter is provided, filter based on the TriggerType via Trigger object trigger_type_ref = raw_filters.get('trigger_type', None) if trigger_type_ref: # 1. Retrieve TriggerType object id which match this trigger_type ref trigger_dbs = Trigger.query(type=trigger_type_ref, only_fields=['ref', 'name', 'pack', 'type']) trigger_refs = [trigger_db.ref for trigger_db in trigger_dbs] raw_filters['trigger'] = trigger_refs if trigger_type_ref and len(raw_filters.get('trigger', [])) == 0: # Empty list means trigger_type_ref filter was provided, but we matched no Triggers so # we should return back empty result return [] trigger_instances = self._get_trigger_instances(exclude_fields=exclude_attributes, include_fields=include_attributes, sort=sort, offset=offset, limit=limit, raw_filters=raw_filters, requester_user=requester_user) return trigger_instances
def test_register_triggers_from_pack(self): base_path = get_fixtures_base_path() pack_dir = os.path.join(base_path, 'dummy_pack_1') trigger_type_dbs = TriggerType.get_all() self.assertEqual(len(trigger_type_dbs), 0) count = triggers_registrar.register_triggers(pack_dir=pack_dir) self.assertEqual(count, 2) # Verify TriggerTypeDB and corresponding TriggerDB objects have been created trigger_type_dbs = TriggerType.get_all() trigger_dbs = Trigger.get_all() self.assertEqual(len(trigger_type_dbs), 2) self.assertEqual(len(trigger_dbs), 2) self.assertEqual(trigger_type_dbs[0].name, 'event_handler') self.assertEqual(trigger_type_dbs[0].pack, 'dummy_pack_1') self.assertEqual(trigger_dbs[0].name, 'event_handler') self.assertEqual(trigger_dbs[0].pack, 'dummy_pack_1') self.assertEqual(trigger_dbs[0].type, 'dummy_pack_1.event_handler') self.assertEqual(trigger_type_dbs[1].name, 'head_sha_monitor') self.assertEqual(trigger_type_dbs[1].pack, 'dummy_pack_1') self.assertEqual(trigger_type_dbs[1].payload_schema['type'], 'object')
def setUp(self): super(ContainerUtilsTest, self).setUp() # Insert mock TriggerDB trigger_db = TriggerDB(name='name1', pack='pack1', type='type1', parameters={'a': 1, 'b': '2', 'c': 'foo'}) self.trigger_db = Trigger.add_or_update(trigger_db)
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_triggers( self, names=["st2.test.trigger1", "st2.test.trigger2", "st2.test.trigger3", "st2.test.trigger4"] ): 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 if name in ["st2.test.trigger4"]: created.parameters = {"url": "sample"} else: created.parameters = {} created = Trigger.add_or_update(created) trigger_dbs.append(created) return trigger_dbs
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 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 _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 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 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_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_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 StackStormDBObjectNotFoundError: retrieved = None self.assertIsNone(retrieved, "managed to retrieve after failure.")
def _create_save_triggertype(): created = TriggerTypeDB() created.pack = 'dummy_pack_1' created.name = 'triggertype-1' created.stupid = 'stupid' created.description = '' created.payload_schema = {} created.parameters_schema = {} return Trigger.add_or_update(created)
def get_all(self, requester_user=None): """ List all triggers. Handles requests: GET /triggers/ """ trigger_dbs = Trigger.get_all() trigger_apis = [TriggerAPI.from_model(trigger_db) for trigger_db in trigger_dbs] return trigger_apis
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 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 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 test_ref_count_trigger_increment(self): post_resp = self.__do_post(self.RULE_1) rule_1_id = self.__get_rule_id(post_resp) self.assertEqual(post_resp.status_int, http_client.CREATED) # ref_count is not served over API. Likely a choice that will prove unwise. triggers = Trigger.get_all(**{'type': post_resp.json['trigger']['type']}) self.assertEqual(len(triggers), 1, 'Exactly 1 should exist') self.assertEqual(triggers[0].ref_count, 1, 'ref_count should be 1') # different rule same params rule_2 = copy.copy(self.RULE_1) rule_2['name'] = rule_2['name'] + '-2' post_resp = self.__do_post(rule_2) rule_2_id = self.__get_rule_id(post_resp) self.assertEqual(post_resp.status_int, http_client.CREATED) triggers = Trigger.get_all(**{'type': post_resp.json['trigger']['type']}) self.assertEqual(len(triggers), 1, 'Exactly 1 should exist') self.assertEqual(triggers[0].ref_count, 2, 'ref_count should be 1') self.__do_delete(rule_1_id) self.__do_delete(rule_2_id)
def test_trigger_cleanup(self): post_resp = self.__do_post(self.RULE_1) rule_1_id = self.__get_rule_id(post_resp) self.assertEqual(post_resp.status_int, http_client.CREATED) rule_2 = copy.copy(self.RULE_1) rule_2['name'] = rule_2['name'] + '-2' post_resp = self.__do_post(rule_2) rule_2_id = self.__get_rule_id(post_resp) self.assertEqual(post_resp.status_int, http_client.CREATED) triggers = Trigger.get_all(**{'type': post_resp.json['trigger']['type']}) self.assertEqual(len(triggers), 1, 'Exactly 1 should exist') self.assertEqual(triggers[0].ref_count, 2, 'ref_count should be 1') self.__do_delete(rule_1_id) self.__do_delete(rule_2_id) # validate cleanup triggers = Trigger.get_all(**{'type': post_resp.json['trigger']['type']}) self.assertEqual(len(triggers), 0, 'Exactly 1 should exist')
def test_register_all_triggers(self): trigger_type_dbs = TriggerType.get_all() self.assertEqual(len(trigger_type_dbs), 0) packs_base_path = get_fixtures_base_path() count = triggers_registrar.register_triggers(packs_base_paths=[packs_base_path]) self.assertEqual(count, 3) # Verify TriggerTypeDB and corresponding TriggerDB objects have been created trigger_type_dbs = TriggerType.get_all() trigger_dbs = Trigger.get_all() self.assertEqual(len(trigger_type_dbs), 3) self.assertEqual(len(trigger_dbs), 3)
def test_register_sensors(self): # Verify DB is empty at the beginning self.assertEqual(len(SensorType.get_all()), 0) self.assertEqual(len(TriggerType.get_all()), 0) self.assertEqual(len(Trigger.get_all()), 0) registrar = SensorsRegistrar() registrar.register_from_packs(base_dirs=[PACKS_DIR]) # Verify objects have been created sensor_dbs = SensorType.get_all() trigger_type_dbs = TriggerType.get_all() trigger_dbs = Trigger.get_all() self.assertEqual(len(sensor_dbs), 2) self.assertEqual(len(trigger_type_dbs), 2) self.assertEqual(len(trigger_dbs), 2) self.assertEqual(sensor_dbs[0].name, 'TestSensor') self.assertEqual(sensor_dbs[0].poll_interval, 10) self.assertTrue(sensor_dbs[0].enabled) self.assertEqual(sensor_dbs[0].metadata_file, 'sensors/test_sensor_1.yaml') self.assertEqual(sensor_dbs[1].name, 'TestSensorDisabled') self.assertEqual(sensor_dbs[1].poll_interval, 10) self.assertFalse(sensor_dbs[1].enabled) self.assertEqual(sensor_dbs[1].metadata_file, 'sensors/test_sensor_2.yaml') self.assertEqual(trigger_type_dbs[0].name, 'trigger_type_1') self.assertEqual(trigger_type_dbs[0].pack, 'pack_with_sensor') self.assertEqual(len(trigger_type_dbs[0].tags), 0) self.assertEqual(trigger_type_dbs[1].name, 'trigger_type_2') self.assertEqual(trigger_type_dbs[1].pack, 'pack_with_sensor') self.assertEqual(len(trigger_type_dbs[1].tags), 2) self.assertEqual(trigger_type_dbs[1].tags[0].name, 'tag1name') self.assertEqual(trigger_type_dbs[1].tags[0].value, 'tag1 value') # Triggered which are registered via sensors have metadata_file pointing to the sensor # definition file self.assertEqual(trigger_type_dbs[0].metadata_file, 'sensors/test_sensor_1.yaml') self.assertEqual(trigger_type_dbs[1].metadata_file, 'sensors/test_sensor_1.yaml') # Verify second call to registration doesn't create a duplicate objects registrar.register_from_packs(base_dirs=[PACKS_DIR]) sensor_dbs = SensorType.get_all() trigger_type_dbs = TriggerType.get_all() trigger_dbs = Trigger.get_all() self.assertEqual(len(sensor_dbs), 2) self.assertEqual(len(trigger_type_dbs), 2) self.assertEqual(len(trigger_dbs), 2) self.assertEqual(sensor_dbs[0].name, 'TestSensor') self.assertEqual(sensor_dbs[0].poll_interval, 10) self.assertEqual(trigger_type_dbs[0].name, 'trigger_type_1') self.assertEqual(trigger_type_dbs[0].pack, 'pack_with_sensor') self.assertEqual(trigger_type_dbs[1].name, 'trigger_type_2') self.assertEqual(trigger_type_dbs[1].pack, 'pack_with_sensor') # Verify sensor and trigger data is updated on registration original_load = registrar._meta_loader.load def mock_load(*args, **kwargs): # Update poll_interval and trigger_type_2 description data = original_load(*args, **kwargs) data['poll_interval'] = 50 data['trigger_types'][1]['description'] = 'test 2' return data registrar._meta_loader.load = mock_load registrar.register_from_packs(base_dirs=[PACKS_DIR]) sensor_dbs = SensorType.get_all() trigger_type_dbs = TriggerType.get_all() trigger_dbs = Trigger.get_all() self.assertEqual(len(sensor_dbs), 2) self.assertEqual(len(trigger_type_dbs), 2) self.assertEqual(len(trigger_dbs), 2) self.assertEqual(sensor_dbs[0].name, 'TestSensor') self.assertEqual(sensor_dbs[0].poll_interval, 50) self.assertEqual(trigger_type_dbs[0].name, 'trigger_type_1') self.assertEqual(trigger_type_dbs[0].pack, 'pack_with_sensor') self.assertEqual(trigger_type_dbs[1].name, 'trigger_type_2') self.assertEqual(trigger_type_dbs[1].pack, 'pack_with_sensor') self.assertEqual(trigger_type_dbs[1].description, 'test 2')
def _update_trigger_ref_count(self, trigger_db, ref_count): """ Non-publishing ref_count update to a TriggerDB. """ trigger_db.ref_count = ref_count Trigger.add_or_update(trigger_db, publish=False, dispatch_trigger=False)
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 __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 setUpClass(cls): super(ReferenceTest, cls).setUpClass() trigger = TriggerDB(pack='dummy_pack_1', name='trigger-1') cls.__model = Trigger.add_or_update(trigger) cls.__ref = {'id': str(cls.__model.id), 'name': cls.__model.name}
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 test_get_trigger_db_given_type_and_params(self): # Add dummy triggers trigger_1 = TriggerDB(pack='testpack', name='testtrigger1', type='testpack.testtrigger1') trigger_2 = TriggerDB(pack='testpack', name='testtrigger2', type='testpack.testtrigger2') trigger_3 = TriggerDB(pack='testpack', name='testtrigger3', type='testpack.testtrigger3') trigger_4 = TriggerDB(pack='testpack', name='testtrigger4', type='testpack.testtrigger4', parameters={'ponies': 'unicorn'}) Trigger.add_or_update(trigger_1) Trigger.add_or_update(trigger_2) Trigger.add_or_update(trigger_3) Trigger.add_or_update(trigger_4) # Trigger with no parameters, parameters={} in db trigger_db = trigger_service.get_trigger_db_given_type_and_params( type=trigger_1.type, parameters={}) self.assertEqual(trigger_db, trigger_1) trigger_db = trigger_service.get_trigger_db_given_type_and_params( type=trigger_1.type, parameters=None) self.assertEqual(trigger_db, trigger_1) trigger_db = trigger_service.get_trigger_db_given_type_and_params( type=trigger_1.type, parameters={'fo': 'bar'}) self.assertEqual(trigger_db, None) # Trigger with no parameters, no parameters attribute in the db trigger_db = trigger_service.get_trigger_db_given_type_and_params( type=trigger_2.type, parameters={}) self.assertEqual(trigger_db, trigger_2) trigger_db = trigger_service.get_trigger_db_given_type_and_params( type=trigger_2.type, parameters=None) self.assertEqual(trigger_db, trigger_2) trigger_db = trigger_service.get_trigger_db_given_type_and_params( type=trigger_2.type, parameters={'fo': 'bar'}) self.assertEqual(trigger_db, None) trigger_db = trigger_service.get_trigger_db_given_type_and_params( type=trigger_3.type, parameters={}) self.assertEqual(trigger_db, trigger_3) trigger_db = trigger_service.get_trigger_db_given_type_and_params( type=trigger_3.type, parameters=None) self.assertEqual(trigger_db, trigger_3) # Trigger with parameters trigger_db = trigger_service.get_trigger_db_given_type_and_params( type=trigger_4.type, parameters=trigger_4.parameters) self.assertEqual(trigger_db, trigger_4) trigger_db = trigger_service.get_trigger_db_given_type_and_params( type=trigger_4.type, parameters=None) self.assertEqual(trigger_db, None)
def tearDownClass(cls): Trigger.delete(cls.__model) super(ReferenceTest, cls).tearDownClass()
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 = LiveAction.get_by_id(str(liveaction.id)) self.assertEqual(liveaction.status, 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 _load_triggers_from_db(self): for trigger_type in self._trigger_types: for trigger in Trigger.query(type=trigger_type): LOG.debug('Found existing trigger: %s in db.' % trigger) self._handlers[publishers.CREATE_RK](trigger)
def setUpClass(cls): super(ReferenceTest, cls).setUpClass() trigger = TriggerDB(pack="dummy_pack_1", name="trigger-1") cls.__model = Trigger.add_or_update(trigger) cls.__ref = {"id": str(cls.__model.id), "name": cls.__model.name}