def setUpClass(cls): super(ExecutionCancellationTestCase, cls).setUpClass() for _, fixture in six.iteritems(FIXTURES['actions']): instance = ActionAPI(**fixture) Action.add_or_update(ActionAPI.to_model(instance)) runners_registrar.register_runners()
def setUpClass(cls): super(TestMistralRunner, cls).setUpClass() runners_registrar.register_runner_types() for _, fixture in six.iteritems(FIXTURES['actions']): instance = ActionAPI(**fixture) Action.add_or_update(ActionAPI.to_model(instance))
def test_action_with_notify_crud(self): runnertype = self._create_save_runnertype(metadata=False) saved = self._create_save_action(runnertype, metadata=False) # Update action with notification settings on_complete = NotificationSubSchema(message='Action complete.') saved.notify = NotificationSchema(on_complete=on_complete) saved = Action.add_or_update(saved) # Check if notification settings were set correctly. retrieved = Action.get_by_id(saved.id) self.assertEqual(retrieved.notify.on_complete.message, on_complete.message) # Now reset notify in action to empty and validate it's gone. retrieved.notify = NotificationSchema(on_complete=None) saved = Action.add_or_update(retrieved) retrieved = Action.get_by_id(saved.id) self.assertEqual(retrieved.notify.on_complete, None) # cleanup self._delete([retrieved]) try: retrieved = Action.get_by_id(saved.id) except ValueError: retrieved = None self.assertIsNone(retrieved, 'managed to retrieve after failure.')
def setUpClass(cls): super(MistralRunnerTest, cls).setUpClass() runners_registrar.register_runner_types() for _, fixture in six.iteritems(FIXTURES['actions']): instance = ActionAPI(**fixture) Action.add_or_update(ActionAPI.to_model(instance))
def test_action_with_notify_crud(self): runnertype = self._create_save_runnertype(metadata=False) saved = self._create_save_action(runnertype, metadata=False) # Update action with notification settings on_complete = NotificationSubSchema(message='Action complete.') saved.notify = NotificationSchema(on_complete=on_complete) saved = Action.add_or_update(saved) # Check if notification settings were set correctly. retrieved = Action.get_by_id(saved.id) self.assertEqual(retrieved.notify.on_complete.message, on_complete.message) # Now reset notify in action to empty and validate it's gone. retrieved.notify = NotificationSchema(on_complete=None) saved = Action.add_or_update(retrieved) retrieved = Action.get_by_id(saved.id) self.assertEqual(retrieved.notify.on_complete, None) # cleanup self._delete([retrieved]) try: retrieved = Action.get_by_id(saved.id) except StackStormDBObjectNotFoundError: retrieved = None self.assertIsNone(retrieved, 'managed to retrieve after failure.')
def setup_action_models(cls): action_db = ActionDB() action_db.name = 'action-1' action_db.description = 'awesomeness' action_db.enabled = True action_db.pack = 'wolfpack' action_db.entry_point = '' action_db.runner_type = {'name': 'test-runner'} action_db.parameters = { 'actionstr': {'type': 'string', 'required': True}, 'actionint': {'type': 'number', 'default': 10}, 'runnerdummy': {'type': 'string', 'default': 'actiondummy'}, 'runnerimmutable': {'type': 'string', 'default': 'failed_override'}, 'actionimmutable': {'type': 'string', 'default': 'actionimmutable', 'immutable': True} } RunnerContainerTest.action_db = Action.add_or_update(action_db) action_db = ActionDB() action_db.name = 'action-2' action_db.description = 'awesomeness' action_db.enabled = True action_db.pack = 'wolfpack' action_db.entry_point = '' action_db.runner_type = {'name': 'test-failingrunner'} action_db.parameters = {} RunnerContainerTest.failingaction_db = Action.add_or_update(action_db)
def setUpClass(cls): super(TestActionExecutionHistoryWorker, cls).setUpClass() runners_registrar.register_runners() action_local = ActionAPI(**copy.deepcopy(fixture.ARTIFACTS["actions"]["local"])) Action.add_or_update(ActionAPI.to_model(action_local)) action_chain = ActionAPI(**copy.deepcopy(fixture.ARTIFACTS["actions"]["chain"])) action_chain.entry_point = fixture.PATH + "/chain.yaml" Action.add_or_update(ActionAPI.to_model(action_chain))
def setUpClass(cls): super(TestStreamController, cls).setUpClass() instance = RunnerTypeAPI(**RUNNER_TYPE_1) RunnerType.add_or_update(RunnerTypeAPI.to_model(instance)) instance = ActionAPI(**ACTION_1) Action.add_or_update(ActionAPI.to_model(instance))
def test_schedule_disabled_action(self): self.actiondb.enabled = False Action.add_or_update(self.actiondb) parameters = {'hosts': 'localhost', 'cmd': 'uname -a'} execution = LiveActionDB(action=ACTION_REF, parameters=parameters) self.assertRaises(ValueError, action_service.schedule, execution) self.actiondb.enabled = True Action.add_or_update(self.actiondb)
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 setUpClass(cls): super(TestMistralRunner, cls).setUpClass() runners_registrar.register_runner_types() metadata = fixture.ARTIFACTS['metadata'] action_local = ActionAPI(**copy.deepcopy(metadata['actions']['local'])) Action.add_or_update(ActionAPI.to_model(action_local)) action_wkflow = ActionAPI(**copy.deepcopy(metadata['actions']['workflow-v2'])) Action.add_or_update(ActionAPI.to_model(action_wkflow))
def test_request_disabled_action(self): self.actiondb.enabled = False Action.add_or_update(self.actiondb) parameters = {'hosts': 'localhost', 'cmd': 'uname -a'} execution = LiveActionDB(action=ACTION_REF, parameters=parameters) self.assertRaises(ValueError, action_service.request, execution) self.actiondb.enabled = True Action.add_or_update(self.actiondb)
def setUpClass(cls): super(TestActionExecutionHistoryWorker, cls).setUpClass() runners_registrar.register_runner_types() action_local = ActionAPI(**copy.deepcopy(fixture.ARTIFACTS['actions']['local'])) Action.add_or_update(ActionAPI.to_model(action_local)) action_chain = ActionAPI(**copy.deepcopy(fixture.ARTIFACTS['actions']['chain'])) action_chain.entry_point = fixture.PATH + '/chain.yaml' Action.add_or_update(ActionAPI.to_model(action_chain))
def setUpClass(cls): super(TestMistralRunner, cls).setUpClass() runners_registrar.register_runner_types() metadata = fixture.ARTIFACTS['metadata'] action_local = ActionAPI(**copy.deepcopy(metadata['actions']['local'])) Action.add_or_update(ActionAPI.to_model(action_local)) action_wkflow = ActionAPI( **copy.deepcopy(metadata['actions']['workflow-v2'])) Action.add_or_update(ActionAPI.to_model(action_wkflow))
def setUpClass(cls): super(SchedulerTest, cls).setUpClass() for _, fixture in six.iteritems(FIXTURES['runners']): instance = RunnerTypeAPI(**fixture) RunnerType.add_or_update(RunnerTypeAPI.to_model(instance)) for _, fixture in six.iteritems(FIXTURES['actions']): instance = ActionAPI(**fixture) Action.add_or_update(ActionAPI.to_model(instance))
def setUpClass(cls): super(TestActionExecutionHistoryWorker, cls).setUpClass() runners_registrar.register_runners() action_local = ActionAPI( **copy.deepcopy(fixture.ARTIFACTS["actions"]["local"])) Action.add_or_update(ActionAPI.to_model(action_local)) action_chain = ActionAPI( **copy.deepcopy(fixture.ARTIFACTS["actions"]["chain"])) action_chain.entry_point = fixture.PATH + "/chain.yaml" Action.add_or_update(ActionAPI.to_model(action_chain))
def _restore_action(self, action_db, pack_base_path, temp_sub_dir): restore_temp_action_files( pack_base_path, action_db["metadata_file"], action_db["entry_point"], temp_sub_dir, ) action_db.id = None Action.add_or_update(action_db) remove_temp_action_files(temp_sub_dir)
def setUpClass(cls): super(MistralValidationControllerTest, cls).setUpClass() for _, fixture in six.iteritems(FIXTURES['runners']): instance = RunnerTypeAPI(**fixture) RunnerType.add_or_update(RunnerTypeAPI.to_model(instance)) for _, fixture in six.iteritems(FIXTURES['actions']): instance = ActionAPI(**fixture) Action.add_or_update(ActionAPI.to_model(instance))
def setUpClass(cls): super(DSLTransformTestCase, cls).setUpClass() for _, fixture in six.iteritems(FIXTURES['runners']): instance = RunnerTypeAPI(**fixture) RunnerType.add_or_update(RunnerTypeAPI.to_model(instance)) for _, fixture in six.iteritems(FIXTURES['actions']): instance = ActionAPI(**fixture) Action.add_or_update(ActionAPI.to_model(instance))
def setUpClass(cls): super(DSLTransformTestCase, cls).setUpClass() runners_registrar.register_runner_types() for _, fixture in six.iteritems(FIXTURES['runners']): instance = RunnerTypeAPI(**fixture) RunnerType.add_or_update(RunnerTypeAPI.to_model(instance)) for _, fixture in six.iteritems(FIXTURES['actions']): instance = ActionAPI(**fixture) Action.add_or_update(ActionAPI.to_model(instance))
def setUpClass(cls): super(MistralValidationTest, cls).setUpClass() for _, fixture in six.iteritems(FIXTURES['runners']): instance = RunnerTypeAPI(**fixture) RunnerType.add_or_update(RunnerTypeAPI.to_model(instance)) for _, fixture in six.iteritems(FIXTURES['actions']): instance = ActionAPI(**fixture) Action.add_or_update(ActionAPI.to_model(instance)) cls.validator = wf_validation_utils.get_validator()
def setUpClass(cls): super(MistralValidationTest, cls).setUpClass() for _, fixture in six.iteritems(FIXTURES["runners"]): instance = RunnerTypeAPI(**fixture) RunnerType.add_or_update(RunnerTypeAPI.to_model(instance)) for _, fixture in six.iteritems(FIXTURES["actions"]): instance = ActionAPI(**fixture) Action.add_or_update(ActionAPI.to_model(instance)) cls.validator = wf_validation_utils.get_validator()
def setUpClass(cls): super(DSLTransformTestCase, cls).setUpClass() runners_registrar.register_runner_types() action_local = ActionAPI(**copy.deepcopy(FIXTURES['actions']['local.yaml'])) Action.add_or_update(ActionAPI.to_model(action_local)) for action_name in ['action1', 'action2', 'action3']: metadata = copy.deepcopy(FIXTURES['actions']['local.yaml']) metadata['name'] = action_name metadata['pack'] = 'demo' action = ActionAPI(**metadata) Action.add_or_update(ActionAPI.to_model(action))
def test_request_disabled_action(self): actiondb = self.actiondbs[ACTION['name']] actiondb.enabled = False Action.add_or_update(actiondb) try: parameters = {'hosts': 'localhost', 'cmd': 'uname -a'} execution = LiveActionDB(action=ACTION_REF, parameters=parameters) self.assertRaises(ValueError, action_service.request, execution) except Exception as e: raise e finally: actiondb.enabled = True Action.add_or_update(actiondb)
def test_req_disabled_action(self): actiondb = self.actiondbs[ACTION['name']] actiondb.enabled = False Action.add_or_update(actiondb) try: parameters = {'hosts': '127.0.0.1', 'cmd': 'uname -a'} ex = LiveActionDB(action=ACTION_REF, parameters=parameters) self.assertRaises(ValueError, action_service.request, ex) except Exception as e: raise e finally: actiondb.enabled = True Action.add_or_update(actiondb)
def post(self, action): """ Create a new action. Handles requests: POST /actions/ """ # Perform validation validate_not_part_of_system_pack(action) action_validator.validate_action(action) # Write pack data files to disk (if any are provided) data_files = getattr(action, 'data_files', []) written_data_files = [] if data_files: written_data_files = self._handle_data_files(pack_name=action.pack, data_files=data_files) action_model = ActionAPI.to_model(action) LOG.debug('/actions/ POST verified ActionAPI object=%s', action) action_db = Action.add_or_update(action_model) LOG.debug('/actions/ POST saved ActionDB object=%s', action_db) # Dispatch an internal trigger for each written data file. This way user # automate comitting this files to git using StackStorm rule if written_data_files: self._dispatch_trigger_for_written_data_files( action_db=action_db, written_data_files=written_data_files) extra = {'acion_db': action_db} LOG.audit('Action created. Action.id=%s' % (action_db.id), extra=extra) action_api = ActionAPI.from_model(action_db) return action_api
def setup_action_models(cls): action_db = ActionDB() action_db.name = 'action-1' action_db.description = 'awesomeness' action_db.enabled = True action_db.pack = 'wolfpack' action_db.ref = ResourceReference(name=action_db.name, pack=action_db.pack).ref action_db.entry_point = '' action_db.runner_type = {'name': 'test-runner'} action_db.parameters = { 'actionstr': {'type': 'string', 'position': 1, 'required': True}, 'actionint': {'type': 'number', 'default': 10, 'position': 0}, 'runnerdummy': {'type': 'string', 'default': 'actiondummy'} } ActionDBUtilsTestCase.action_db = Action.add_or_update(action_db) liveaction_db = LiveActionDB() liveaction_db.status = 'initializing' liveaction_db.start_timestamp = get_datetime_utc_now() liveaction_db.action = ActionDBUtilsTestCase.action_db.ref params = { 'actionstr': 'foo', 'some_key_that_aint_exist_in_action_or_runner': 'bar', 'runnerint': 555 } liveaction_db.parameters = params ActionDBUtilsTestCase.liveaction_db = LiveAction.add_or_update(liveaction_db)
def _register_action(self, pack, action): content = self._meta_loader.load(action) pack_field = content.get('pack', None) if not pack_field: content['pack'] = pack pack_field = pack if pack_field != pack: raise Exception('Model is in pack "%s" but field "pack" is different: %s' % (pack, pack_field)) action_api = ActionAPI(**content) action_api.validate() action_validator.validate_action(action_api) model = ActionAPI.to_model(action_api) action_ref = ResourceReference.to_string_reference(pack=pack, name=str(content['name'])) existing = action_utils.get_action_by_ref(action_ref) if not existing: LOG.debug('Action %s not found. Creating new one with: %s', action_ref, content) else: LOG.debug('Action %s found. Will be updated from: %s to: %s', action_ref, existing, model) model.id = existing.id try: model = Action.add_or_update(model) extra = {'action_db': model} LOG.audit('Action updated. Action %s from %s.', model, action, extra=extra) except Exception: LOG.exception('Failed to write action to db %s.', model.name) raise
def setup_action_models(cls): pack = 'wolfpack' name = 'action-1' parameters = { 'actionint': {'type': 'number', 'default': 10, 'position': 0}, 'actionfloat': {'type': 'float', 'required': False, 'position': 1}, 'actionstr': {'type': 'string', 'required': True, 'position': 2}, 'actionbool': {'type': 'boolean', 'required': False, 'position': 3}, 'actionlist': {'type': 'list', 'required': False, 'position': 4}, 'actionobject': {'type': 'object', 'required': False, 'position': 5}, 'actionnull': {'type': 'null', 'required': False, 'position': 6}, 'runnerdummy': {'type': 'string', 'default': 'actiondummy'} } action_db = ActionDB(pack=pack, name=name, description='awesomeness', enabled=True, ref=ResourceReference(name=name, pack=pack).ref, entry_point='', runner_type={'name': 'test-runner'}, parameters=parameters) ActionDBUtilsTestCase.action_db = Action.add_or_update(action_db) liveaction_db = LiveActionDB() liveaction_db.status = 'initializing' liveaction_db.start_timestamp = get_datetime_utc_now() liveaction_db.action = ActionDBUtilsTestCase.action_db.ref params = { 'actionstr': 'foo', 'some_key_that_aint_exist_in_action_or_runner': 'bar', 'runnerint': 555 } liveaction_db.parameters = params ActionDBUtilsTestCase.liveaction_db = LiveAction.add_or_update(liveaction_db)
def _register_action(self, pack, action): with open(action, 'r') as fd: try: content = json.load(fd) except ValueError: LOG.exception('Failed loading action json from %s.', action) raise try: model = Action.get_by_name(str(content['name'])) except ValueError: model = ActionDB() model.name = content['name'] model.description = content['description'] model.enabled = content['enabled'] model.pack = pack model.entry_point = content['entry_point'] model.parameters = content.get('parameters', {}) runner_type = str(content['runner_type']) valid_runner_type, runner_type_db = self._has_valid_runner_type(runner_type) if valid_runner_type: model.runner_type = {'name': runner_type_db.name} else: LOG.exception('Runner type %s doesn\'t exist.') raise try: model = Action.add_or_update(model) LOG.audit('Action created. Action %s from %s.', model, action) except Exception: LOG.exception('Failed to write action to db %s.', model.name) raise
def test_uid_is_populated_on_save(self): pack_1_db = PackDB( ref="test_pack", name="test", description="foo", version="1.0.0", author="dev", email="*****@*****.**", ) pack_1_db = Pack.add_or_update(pack_1_db) pack_1_db.reload() self.assertEqual(pack_1_db.uid, "pack:test_pack") action_1_db = ActionDB( name="local", pack="core", ref="core.local", entry_point="", runner_type={"name": "local-shell-cmd"}, ) action_1_db = Action.add_or_update(action_1_db) action_1_db.reload() self.assertEqual(action_1_db.uid, "action:core:local")
def setUpClass(cls): super(TestActionExecutionService, cls).setUpClass() cls.runner = RunnerTypeAPI(**RUNNER) cls.runnerdb = RunnerType.add_or_update( RunnerTypeAPI.to_model(cls.runner)) cls.action = ActionAPI(**ACTION) cls.actiondb = Action.add_or_update(ActionAPI.to_model(cls.action))
def _register_action(self, pack, action): content = self._meta_loader.load(action) try: model = Action.get_by_name(str(content['name'])) except ValueError: model = ActionDB() model.name = content['name'] model.description = content['description'] model.enabled = content['enabled'] model.pack = pack model.entry_point = content['entry_point'] model.parameters = content.get('parameters', {}) runner_type = str(content['runner_type']) valid_runner_type, runner_type_db = self._has_valid_runner_type( runner_type) if valid_runner_type: model.runner_type = {'name': runner_type_db.name} else: LOG.exception('Runner type %s doesn\'t exist.', runner_type) raise try: model = Action.add_or_update(model) LOG.audit('Action created. Action %s from %s.', model, action) except Exception: LOG.exception('Failed to write action to db %s.', model.name) raise
def setUpClass(cls): super(TestActionExecutionService, cls).setUpClass() cls.runner = RunnerTypeAPI(**RUNNER) cls.runnerdb = RunnerType.add_or_update( RunnerTypeAPI.to_model(cls.runner)) runner_api = RunnerTypeAPI(**RUNNER_ACTION_CHAIN) RunnerType.add_or_update(RunnerTypeAPI.to_model(runner_api)) cls.actions = { ACTION['name']: ActionAPI(**ACTION), ACTION_WORKFLOW['name']: ActionAPI(**ACTION_WORKFLOW), ACTION_OVR_PARAM['name']: ActionAPI(**ACTION_OVR_PARAM), ACTION_OVR_PARAM_MUTABLE['name']: ActionAPI(**ACTION_OVR_PARAM_MUTABLE), ACTION_OVR_PARAM_IMMUTABLE['name']: ActionAPI(**ACTION_OVR_PARAM_IMMUTABLE), ACTION_OVR_PARAM_BAD_ATTR['name']: ActionAPI(**ACTION_OVR_PARAM_BAD_ATTR), ACTION_OVR_PARAM_BAD_ATTR_NOOP['name']: ActionAPI(**ACTION_OVR_PARAM_BAD_ATTR_NOOP) } cls.actiondbs = { name: Action.add_or_update(ActionAPI.to_model(action)) for name, action in six.iteritems(cls.actions) } cls.container = RunnerContainer()
def _create_save_action(runnertype, metadata=False): name = 'action-1' pack = 'wolfpack' ref = ResourceReference(pack=pack, name=name).ref created = ActionDB(name=name, description='awesomeness', enabled=True, entry_point='/tmp/action.py', pack=pack, ref=ref, runner_type={'name': runnertype.name}) if not metadata: created.parameters = {'p1': None, 'p2': None, 'p3': None} else: created.parameters = { 'p1': { 'type': 'string', 'required': True }, 'p2': { 'type': 'number', 'default': 2868 }, 'p3': { 'type': 'boolean', 'default': False } } return Action.add_or_update(created)
def setUpClass(cls): super(TestActionExecutionService, cls).setUpClass() cls.runner = RunnerTypeAPI(**RUNNER) cls.runnerdb = RunnerType.add_or_update(RunnerTypeAPI.to_model(cls.runner)) cls.action = ActionAPI(**ACTION) cls.actiondb = Action.add_or_update(ActionAPI.to_model(cls.action)) cls.container = RunnerContainer()
def put(self, action_ref_or_id, action): action_db = self._get_by_ref_or_id(ref_or_id=action_ref_or_id) action_id = action_db.id try: validate_not_part_of_system_pack(action_db) except ValueValidationException as e: abort(http_client.BAD_REQUEST, str(e)) if not getattr(action, 'pack', None): action.pack = action_db.pack try: action_validator.validate_action(action) except ValueValidationException as e: abort(http_client.BAD_REQUEST, str(e)) return try: action_db = ActionAPI.to_model(action) action_db.id = action_id action_db = Action.add_or_update(action_db) except (ValidationError, ValueError) as e: LOG.exception('Unable to update action data=%s', action) abort(http_client.BAD_REQUEST, str(e)) return action_api = ActionAPI.from_model(action_db) LOG.debug('PUT /actions/ client_result=%s', action_api) return action_api
def _register_action(self, pack, action): content = self._meta_loader.load(action) action_ref = ResourceReference(pack=pack, name=str(content['name'])) model = action_utils.get_action_by_ref(action_ref) if not model: model = ActionDB() model.name = content['name'] model.description = content['description'] model.enabled = content['enabled'] model.pack = pack model.entry_point = content['entry_point'] model.parameters = content.get('parameters', {}) runner_type = str(content['runner_type']) valid_runner_type, runner_type_db = self._has_valid_runner_type(runner_type) if valid_runner_type: model.runner_type = {'name': runner_type_db.name} else: LOG.exception('Runner type %s doesn\'t exist.', runner_type) raise try: model = Action.add_or_update(model) LOG.audit('Action created. Action %s from %s.', model, action) except Exception: LOG.exception('Failed to write action to db %s.', model.name) raise
def post(self, action): """ Create a new action. Handles requests: POST /actions/ """ if not hasattr(action, 'pack'): setattr(action, 'pack', DEFAULT_PACK_NAME) try: action_validator.validate_action(action) except ValueValidationException as e: abort(http_client.BAD_REQUEST, str(e)) return # ActionsController._validate_action_parameters(action, runnertype_db) action_model = ActionAPI.to_model(action) LOG.debug('/actions/ POST verified ActionAPI object=%s', action) action_db = Action.add_or_update(action_model) LOG.debug('/actions/ POST saved ActionDB object=%s', action_db) extra = {'action_db': action_db} LOG.audit('Action created. Action.id=%s' % (action_db.id), extra=extra) action_api = ActionAPI.from_model(action_db) return action_api
def post(self, action): """ Create a new action. Handles requests: POST /actions/ """ # Perform validation validate_not_part_of_system_pack(action) action_validator.validate_action(action) # Write pack data files to disk (if any are provided) data_files = getattr(action, 'data_files', []) written_data_files = [] if data_files: written_data_files = self._handle_data_files(pack_name=action.pack, data_files=data_files) action_model = ActionAPI.to_model(action) LOG.debug('/actions/ POST verified ActionAPI object=%s', action) action_db = Action.add_or_update(action_model) LOG.debug('/actions/ POST saved ActionDB object=%s', action_db) # Dispatch an internal trigger for each written data file. This way user # automate comitting this files to git using StackStorm rule if written_data_files: self._dispatch_trigger_for_written_data_files(action_db=action_db, written_data_files=written_data_files) extra = {'acion_db': action_db} LOG.audit('Action created. Action.id=%s' % (action_db.id), extra=extra) action_api = ActionAPI.from_model(action_db) return action_api
def setUpClass(cls): super(SchedulingPolicyTest, cls).setUpClass() # Register runners runners_registrar.register_runners() for _, fixture in six.iteritems(FIXTURES['actions']): instance = ActionAPI(**fixture) Action.add_or_update(ActionAPI.to_model(instance)) for _, fixture in six.iteritems(FIXTURES['policytypes']): instance = PolicyTypeAPI(**fixture) PolicyType.add_or_update(PolicyTypeAPI.to_model(instance)) for _, fixture in six.iteritems(FIXTURES['policies']): instance = PolicyAPI(**fixture) Policy.add_or_update(PolicyAPI.to_model(instance))
def setUpClass(cls): super(ActionParamsUtilsTest, cls).setUpClass() cls.runnertype = RunnerTypeAPI( **FIXTURES['runners']['testrunner1.yaml']) cls.runnertype_db = RunnerType.add_or_update( RunnerTypeAPI.to_model(cls.runnertype)) cls.action = ActionAPI(**FIXTURES['actions']['action1.yaml']) cls.action_db = Action.add_or_update(ActionAPI.to_model(cls.action))
def setUpClass(cls): super(PolicyTest, cls).setUpClass() for _, fixture in six.iteritems(FIXTURES['runners']): instance = RunnerTypeAPI(**fixture) RunnerType.add_or_update(RunnerTypeAPI.to_model(instance)) for _, fixture in six.iteritems(FIXTURES['actions']): instance = ActionAPI(**fixture) Action.add_or_update(ActionAPI.to_model(instance)) for _, fixture in six.iteritems(FIXTURES['policytypes']): instance = PolicyTypeAPI(**fixture) PolicyType.add_or_update(PolicyTypeAPI.to_model(instance)) for _, fixture in six.iteritems(FIXTURES['policies']): instance = PolicyAPI(**fixture) Policy.add_or_update(PolicyAPI.to_model(instance))
def _register_action(self, pack, action): content = self._meta_loader.load(action) pack_field = content.get('pack', None) if not pack_field: content['pack'] = pack pack_field = pack if pack_field != pack: raise Exception( 'Model is in pack "%s" but field "pack" is different: %s' % (pack, pack_field)) action_api = ActionAPI(**content) try: action_api.validate() except jsonschema.ValidationError as e: # We throw a more user-friendly exception on invalid parameter name msg = str(e) is_invalid_parameter_name = 'Additional properties are not allowed' in msg is_invalid_parameter_name &= 'in schema[\'properties\'][\'parameters\']' in msg if is_invalid_parameter_name: parameter_name = re.search('\'(.+?)\' was unexpected', msg).groups()[0] new_msg = ( 'Parameter name "%s" is invalid. Valid characters for parameter name ' 'are [a-zA-Z0-0_].' % (parameter_name)) new_msg += '\n\n' + msg raise jsonschema.ValidationError(new_msg) raise e action_validator.validate_action(action_api) model = ActionAPI.to_model(action_api) action_ref = ResourceReference.to_string_reference( pack=pack, name=str(content['name'])) existing = action_utils.get_action_by_ref(action_ref) if not existing: LOG.debug('Action %s not found. Creating new one with: %s', action_ref, content) else: LOG.debug('Action %s found. Will be updated from: %s to: %s', action_ref, existing, model) model.id = existing.id try: model = Action.add_or_update(model) extra = {'action_db': model} LOG.audit('Action updated. Action %s from %s.', model, action, extra=extra) except Exception: LOG.exception('Failed to write action to db %s.', model.name) raise
def post(self, action): """ Create a new action. Handles requests: POST /actions/ """ LOG.info('POST /actions/ with action data=%s', action) if not hasattr(action, 'enabled'): LOG.debug( 'POST /actions/ incoming action data has enabled field unset. ' 'Defaulting enabled to True.') setattr(action, 'enabled', True) else: action.enabled = bool(action.enabled) if not hasattr(action, 'pack'): setattr(action, 'pack', DEFAULT_PACK_NAME) try: action_validator.validate_action(action) except ValueValidationException as e: abort(http_client.BAD_REQUEST, str(e)) return # ActionsController._validate_action_parameters(action, runnertype_db) action_model = ActionAPI.to_model(action) LOG.debug('/actions/ POST verified ActionAPI object=%s', action) try: action_db = Action.add_or_update(action_model) except StackStormDBObjectConflictError as e: # If an existing DB object conflicts with new object then raise error. LOG.warn( '/actions/ POST unable to save ActionDB object "%s" due to uniqueness ' 'conflict. %s', action_model, str(e)) abort(http_client.CONFLICT, str(e), body={'conflict-id': e.conflict_id}) return except Exception as e: LOG.exception( '/actions/ POST unable to save ActionDB object "%s". %s', action_model, e) abort(http_client.INTERNAL_SERVER_ERROR, str(e)) return LOG.debug('/actions/ POST saved ActionDB object=%s', action_db) LOG.audit('Action created. Action=%s', action_db) action_api = ActionAPI.from_model(action_db) LOG.debug('POST /actions/ client_result=%s', action_api) return action_api
def setUp(self): EventletTestCase.setUpClass() DbTestCase.setUpClass() for _, fixture in six.iteritems(FIXTURES["runners"]): instance = RunnerTypeAPI(**fixture) RunnerType.add_or_update(RunnerTypeAPI.to_model(instance)) for _, fixture in six.iteritems(FIXTURES["actions"]): instance = ActionAPI(**fixture) Action.add_or_update(ActionAPI.to_model(instance)) for _, fixture in six.iteritems(FIXTURES["policytypes"]): instance = PolicyTypeAPI(**fixture) PolicyType.add_or_update(PolicyTypeAPI.to_model(instance)) for _, fixture in six.iteritems(FIXTURES["policies"]): instance = PolicyAPI(**fixture) Policy.add_or_update(PolicyAPI.to_model(instance))
def setUpClass(cls): EventletTestCase.setUpClass() DbTestCase.setUpClass() for _, fixture in six.iteritems(FIXTURES['runners']): instance = RunnerTypeAPI(**fixture) RunnerType.add_or_update(RunnerTypeAPI.to_model(instance)) for _, fixture in six.iteritems(FIXTURES['actions']): instance = ActionAPI(**fixture) Action.add_or_update(ActionAPI.to_model(instance)) for _, fixture in six.iteritems(FIXTURES['policytypes']): instance = PolicyTypeAPI(**fixture) PolicyType.add_or_update(PolicyTypeAPI.to_model(instance)) for _, fixture in six.iteritems(FIXTURES['policies']): instance = PolicyAPI(**fixture) Policy.add_or_update(PolicyAPI.to_model(instance))
def post(self, action, requester_user): """ Create a new action. Handles requests: POST /actions/ """ permission_type = PermissionType.ACTION_CREATE rbac_utils = get_rbac_backend().get_utils_class() rbac_utils.assert_user_has_resource_api_permission( user_db=requester_user, resource_api=action, permission_type=permission_type) try: # Perform validation validate_not_part_of_system_pack(action) action_validator.validate_action(action) except ( ValidationError, ValueError, ValueValidationException, InvalidActionParameterException, ) as e: LOG.exception("Unable to create action data=%s", action) abort(http_client.BAD_REQUEST, six.text_type(e)) return # Write pack data files to disk (if any are provided) data_files = getattr(action, "data_files", []) written_data_files = [] if data_files: written_data_files = self._handle_data_files(pack_ref=action.pack, data_files=data_files) action_model = ActionAPI.to_model(action) LOG.debug("/actions/ POST verified ActionAPI object=%s", action) action_db = Action.add_or_update(action_model) LOG.debug("/actions/ POST saved ActionDB object=%s", action_db) # Dispatch an internal trigger for each written data file. This way user # automate comitting this files to git using StackStorm rule if written_data_files: self._dispatch_trigger_for_written_data_files( action_db=action_db, written_data_files=written_data_files) extra = {"acion_db": action_db} LOG.audit("Action created. Action.id=%s" % (action_db.id), extra=extra) action_api = ActionAPI.from_model(action_db) return Response(json=action_api, status=http_client.CREATED)
def _register_action(self, pack, action): content = self._meta_loader.load(action) pack_field = content.get('pack', None) if not pack_field: content['pack'] = pack pack_field = pack if pack_field != pack: raise Exception('Model is in pack "%s" but field "pack" is different: %s' % (pack, pack_field)) action_api = ActionAPI(**content) try: action_api.validate() except jsonschema.ValidationError as e: # We throw a more user-friendly exception on invalid parameter name msg = str(e) is_invalid_parameter_name = 'does not match any of the regexes: ' in msg if is_invalid_parameter_name: match = re.search('\'(.+?)\' does not match any of the regexes', msg) if match: parameter_name = match.groups()[0] else: parameter_name = 'unknown' new_msg = ('Parameter name "%s" is invalid. Valid characters for parameter name ' 'are [a-zA-Z0-0_].' % (parameter_name)) new_msg += '\n\n' + msg raise jsonschema.ValidationError(new_msg) raise e action_validator.validate_action(action_api) model = ActionAPI.to_model(action_api) action_ref = ResourceReference.to_string_reference(pack=pack, name=str(content['name'])) existing = action_utils.get_action_by_ref(action_ref) if not existing: LOG.debug('Action %s not found. Creating new one with: %s', action_ref, content) else: LOG.debug('Action %s found. Will be updated from: %s to: %s', action_ref, existing, model) model.id = existing.id try: model = Action.add_or_update(model) extra = {'action_db': model} LOG.audit('Action updated. Action %s from %s.', model, action, extra=extra) except Exception: LOG.exception('Failed to write action to db %s.', model.name) raise
def post(self, action): """ Create a new action. Handles requests: POST /actions/ """ LOG.info('POST /actions/ with action data=%s', action) if not hasattr(action, 'enabled'): LOG.debug('POST /actions/ incoming action data has enabled field unset. ' 'Defaulting enabled to True.') setattr(action, 'enabled', True) else: action.enabled = bool(action.enabled) if not hasattr(action, 'pack'): setattr(action, 'pack', 'default') try: action_validator.validate_action(action) except ValueValidationException as e: abort(http_client.BAD_REQUEST, str(e)) return # ActionsController._validate_action_parameters(action, runnertype_db) action_model = ActionAPI.to_model(action) LOG.debug('/actions/ POST verified ActionAPI object=%s', action) try: action_db = Action.add_or_update(action_model) except NotUniqueError as e: # If an existing DB object conflicts with new object then raise error. LOG.warn('/actions/ POST unable to save ActionDB object "%s" due to uniqueness ' 'conflict. %s', action_model, str(e)) abort(http_client.CONFLICT, str(e)) return except Exception as e: LOG.exception('/actions/ POST unable to save ActionDB object "%s". %s', action_model, e) abort(http_client.INTERNAL_SERVER_ERROR, str(e)) return LOG.debug('/actions/ POST saved ActionDB object=%s', action_db) LOG.audit('Action created. Action=%s', action_db) action_api = ActionAPI.from_model(action_db) LOG.debug('POST /actions/ client_result=%s', action_api) return action_api
def test_uid_is_populated_on_save(self): pack_1_db = PackDB(ref='test_pack', name='test', description='foo', version='1.0', author='dev', email='*****@*****.**') pack_1_db = Pack.add_or_update(pack_1_db) pack_1_db.reload() self.assertEqual(pack_1_db.uid, 'pack:test_pack') action_1_db = ActionDB(name='local', pack='core', ref='core.local', entry_point='', runner_type={'name': 'local-shell-cmd'}) action_1_db = Action.add_or_update(action_1_db) action_1_db.reload() self.assertEqual(action_1_db.uid, 'action:core:local')
def test_uid_is_populated_on_save(self): pack_1_db = PackDB(ref='test_pack', name='test', description='foo', version='1.0.0', author='dev', email='*****@*****.**') pack_1_db = Pack.add_or_update(pack_1_db) pack_1_db.reload() self.assertEqual(pack_1_db.uid, 'pack:test_pack') action_1_db = ActionDB(name='local', pack='core', ref='core.local', entry_point='', runner_type={'name': 'local-shell-cmd'}) action_1_db = Action.add_or_update(action_1_db) action_1_db.reload() self.assertEqual(action_1_db.uid, 'action:core:local')