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 setUp(self):
super(MistralRunnerPolicyTest, self).setUp()
# Start with a clean database for each test.
self._establish_connection_and_re_create_db()
# Register runners.
runnersregistrar.register_runners()
actions_registrar = actionsregistrar.ActionsRegistrar(
use_pack_cache=False,
fail_on_failure=True
)
for pack in PACKS:
actions_registrar.register_from_pack(pack)
# Register policies required for the tests.
policiesregistrar.register_policy_types(st2common)
policies_registrar = policiesregistrar.PolicyRegistrar(
use_pack_cache=False,
fail_on_failure=True
)
for pack in PACKS:
policies_registrar.register_from_pack(pack)
def setUpClass(cls):
super(MistralRunnerCallbackTest, cls).setUpClass()
# Override the retry configuration here otherwise st2tests.config.parse_args
# in ExecutionDbTestCase.setUpClass will reset these overrides.
cfg.CONF.set_override('retry_exp_msec', 100, group='mistral')
cfg.CONF.set_override('retry_exp_max_msec', 200, group='mistral')
cfg.CONF.set_override('retry_stop_max_msec', 200, group='mistral')
cfg.CONF.set_override('api_url', 'http://0.0.0.0:9101', group='auth')
# Register runners.
runnersregistrar.register_runners()
# Register test pack(s).
actions_registrar = actionsregistrar.ActionsRegistrar(
use_pack_cache=False,
fail_on_failure=True
)
for pack in PACKS:
actions_registrar.register_from_pack(pack)
# Get an instance of the callback module and reference to mistral status map
cls.callback_module = runner_base.get_callback_module(MISTRAL_RUNNER_NAME)
cls.callback_class = cls.callback_module.get_instance()
cls.status_map = cls.callback_module.STATUS_MAP
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 setUp(self):
super(MistralRunnerPolicyTest, self).setUp()
# Start with a clean database for each test.
self._establish_connection_and_re_create_db()
# Register runners.
runnersregistrar.register_runners()
actions_registrar = actionsregistrar.ActionsRegistrar(
use_pack_cache=False,
fail_on_failure=True
)
for pack in PACKS:
actions_registrar.register_from_pack(pack)
# Register policies required for the tests.
policiesregistrar.register_policy_types(st2common)
policies_registrar = policiesregistrar.PolicyRegistrar(
use_pack_cache=False,
fail_on_failure=True
)
for pack in PACKS:
policies_registrar.register_from_pack(pack)
def _do_setUpClass(cls):
tests_config.parse_args()
cfg.CONF.set_default('enable', cls.enable_auth, group='auth')
cfg.CONF.set_override(name='enable', override=False, group='rbac')
opts = cfg.CONF.api_pecan
cfg_dict = {
'app': {
'root': opts.root,
'template_path': opts.template_path,
'modules': opts.modules,
'debug': opts.debug,
'auth_enable': opts.auth_enable,
'errors': {'__force_dict__': True},
'guess_content_type_from_ext': False
}
}
# TODO(manas) : register action types here for now. RunnerType registration can be moved
# to posting to /runnertypes but that implies implementing POST.
runners_registrar.register_runners()
cls.app = load_test_app(config=cfg_dict)
def setUpClass(cls):
super(MistralRunnerCallbackTest, cls).setUpClass()
# Override the retry configuration here otherwise st2tests.config.parse_args
# in ExecutionDbTestCase.setUpClass will reset these overrides.
cfg.CONF.set_override('retry_exp_msec', 100, group='mistral')
cfg.CONF.set_override('retry_exp_max_msec', 200, group='mistral')
cfg.CONF.set_override('retry_stop_max_msec', 200, group='mistral')
cfg.CONF.set_override('api_url', 'http://0.0.0.0:9101', group='auth')
# Register runners.
runnersregistrar.register_runners()
# Register test pack(s).
actions_registrar = actionsregistrar.ActionsRegistrar(
use_pack_cache=False, fail_on_failure=True)
for pack in PACKS:
actions_registrar.register_from_pack(pack)
# Get an instance of the callback module and reference to mistral status map
cls.callback_module = runner_base.get_callback_module(
MISTRAL_RUNNER_NAME)
cls.callback_class = cls.callback_module.get_instance()
cls.status_map = cls.callback_module.STATUS_MAP
def setUpClass(cls):
super(WorkerTestCase, cls).setUpClass()
runners_registrar.register_runners()
models = WorkerTestCase.fixtures_loader.save_fixtures_to_db(
fixtures_pack=FIXTURES_PACK, fixtures_dict=TEST_FIXTURES)
WorkerTestCase.local_action_db = models['actions']['local.yaml']
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(SchedulerTest, 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))
def setUpClass(cls):
ExecutionDbTestCase.setUpClass()
# Register runners
runners_registrar.register_runners()
# Register common policy types
register_policy_types(st2common)
loader = FixturesLoader()
loader.save_fixtures_to_db(fixtures_pack=PACK, fixtures_dict=TEST_FIXTURES)
def setUpClass(cls):
ExecutionDbTestCase.setUpClass()
# Register runners
runners_registrar.register_runners()
# Register common policy types
register_policy_types(st2common)
loader = FixturesLoader()
loader.save_fixtures_to_db(fixtures_pack=PACK,
fixtures_dict=TEST_FIXTURES)
def setUpClass(cls):
super(WorkflowServiceIdentifyOrphansTest, cls).setUpClass()
# Register runners.
runnersregistrar.register_runners()
# Register test pack(s).
actions_registrar = actionsregistrar.ActionsRegistrar(
use_pack_cache=False, fail_on_failure=True)
for pack in PACKS:
actions_registrar.register_from_pack(pack)
def _do_setUpClass(cls):
tests_config.parse_args()
cfg.CONF.set_default('enable', cls.enable_auth, group='auth')
cfg.CONF.set_override(name='enable', override=False, group='rbac')
# TODO(manas) : register action types here for now. RunnerType registration can be moved
# to posting to /runnertypes but that implies implementing POST.
runners_registrar.register_runners()
cls.app = TestApp(app.setup_app())
def setUpClass(cls):
super(PolicyServiceTestCase, cls).setUpClass()
# Register runners
runners_registrar.register_runners()
# Register common policy types
policies_registrar.register_policy_types(st2common)
loader = fixtures.FixturesLoader()
loader.save_fixtures_to_db(fixtures_pack=PACK,
fixtures_dict=TEST_FIXTURES)
def setUpClass(cls):
super(PolicyServiceTestCase, cls).setUpClass()
# Register runners
runners_registrar.register_runners()
# Register common policy types
policies_registrar.register_policy_types(st2common)
loader = fixtures.FixturesLoader()
loader.save_fixtures_to_db(fixtures_pack=PACK,
fixtures_dict=TEST_FIXTURES)
def setUpClass(cls):
super(WorkflowExecutionWriteConflictTest, cls).setUpClass()
# Register runners.
runnersregistrar.register_runners()
# Register test pack(s).
actions_registrar = actionsregistrar.ActionsRegistrar(
use_pack_cache=False, fail_on_failure=True)
for pack in PACKS:
actions_registrar.register_from_pack(pack)
def setUpClass(cls):
super(OrquestaRunnerTest, cls).setUpClass()
# Register runners.
runnersregistrar.register_runners()
# Register test pack(s).
actions_registrar = actionsregistrar.ActionsRegistrar(
use_pack_cache=False, fail_on_failure=True)
for pack in PACKS:
actions_registrar.register_from_pack(pack)
def _do_setUpClass(cls):
tests_config.parse_args()
cfg.CONF.set_default("enable", cls.enable_auth, group="auth")
cfg.CONF.set_override(name="enable", override=False, group="rbac")
# TODO(manas) : register action types here for now. RunnerType registration can be moved
# to posting to /runnertypes but that implies implementing POST.
if cls.register_runners:
runners_registrar.register_runners()
cls.app = TestApp(cls.app_module.setup_app())
def setUpClass(cls):
super(BaseRuleEnforcerTestCase, cls).setUpClass()
runners_registrar.register_runners()
# Create TriggerTypes before creation of Rule to avoid failure. Rule requires the
# Trigger and therefore TriggerType to be created prior to rule creation.
cls.models = FixturesLoader().save_fixtures_to_db(
fixtures_pack=PACK, fixtures_dict=FIXTURES_1)
cls.models.update(FixturesLoader().save_fixtures_to_db(
fixtures_pack=PACK, fixtures_dict=FIXTURES_2))
MOCK_TRIGGER_INSTANCE.trigger = reference.get_ref_from_model(
cls.models['triggers']['trigger1.yaml'])
def _do_setUpClass(cls):
tests_config.parse_args()
cfg.CONF.set_default('enable', cls.enable_auth, group='auth')
cfg.CONF.set_override(name='enable', override=False, group='rbac')
# TODO(manas) : register action types here for now. RunnerType registration can be moved
# to posting to /runnertypes but that implies implementing POST.
if cls.register_runners:
runners_registrar.register_runners()
cls.app = TestApp(cls.app_module.setup_app())
def setUpClass(cls):
super(BaseRuleEnforcerTestCase, cls).setUpClass()
runners_registrar.register_runners()
# Create TriggerTypes before creation of Rule to avoid failure. Rule requires the
# Trigger and therefore TriggerType to be created prior to rule creation.
cls.models = FixturesLoader().save_fixtures_to_db(
fixtures_pack=PACK, fixtures_dict=FIXTURES_1)
cls.models.update(FixturesLoader().save_fixtures_to_db(
fixtures_pack=PACK, fixtures_dict=FIXTURES_2))
MOCK_TRIGGER_INSTANCE.trigger = reference.get_ref_from_model(
cls.models["triggers"]["trigger1.yaml"])
def setUpClass(cls):
super(WorkflowInspectionControllerTest, cls).setUpClass()
st2tests.WorkflowTestCase.setUpClass()
# Register runners.
runnersregistrar.register_runners()
# Register test pack(s).
actions_registrar = actionsregistrar.ActionsRegistrar(
use_pack_cache=False, fail_on_failure=True)
for pack in PACKS:
actions_registrar.register_from_pack(pack)
def setUpClass(cls):
super(MistralRunnerTest, cls).setUpClass()
cfg.CONF.set_override('api_url', 'http://0.0.0.0:9101', group='auth')
# Register runners.
runnersregistrar.register_runners()
# Register test pack(s).
actions_registrar = actionsregistrar.ActionsRegistrar(
use_pack_cache=False, fail_on_failure=True)
for pack in PACKS:
actions_registrar.register_from_pack(pack)
def setUpClass(cls):
super(OrquestaRunnerTest, cls).setUpClass()
# Register runners.
runnersregistrar.register_runners()
# Register test pack(s).
actions_registrar = actionsregistrar.ActionsRegistrar(
use_pack_cache=False,
fail_on_failure=True
)
for pack in PACKS:
actions_registrar.register_from_pack(pack)
def setUpClass(cls):
super(WorkflowExecutionWriteConflictTest, cls).setUpClass()
# Register runners.
runnersregistrar.register_runners()
# Register test pack(s).
actions_registrar = actionsregistrar.ActionsRegistrar(
use_pack_cache=False,
fail_on_failure=True
)
for pack in PACKS:
actions_registrar.register_from_pack(pack)
def setUpClass(cls):
super(OrquestaRunnerTest, cls).setUpClass()
# Register runners and policy types.
runnersregistrar.register_runners()
policiesregistrar.register_policy_types(st2common)
# Register test pack(s).
registrar_options = {'use_pack_cache': False, 'fail_on_failure': True}
actions_registrar = actionsregistrar.ActionsRegistrar(**registrar_options)
policies_registrar = policiesregistrar.PolicyRegistrar(**registrar_options)
for pack in PACKS:
actions_registrar.register_from_pack(pack)
policies_registrar.register_from_pack(pack)
def setUpClass(cls):
super(OrquestaRunnerTest, cls).setUpClass()
# Register runners and policy types.
runnersregistrar.register_runners()
policiesregistrar.register_policy_types(st2common)
# Register test pack(s).
registrar_options = {'use_pack_cache': False, 'fail_on_failure': True}
actions_registrar = actionsregistrar.ActionsRegistrar(**registrar_options)
policies_registrar = policiesregistrar.PolicyRegistrar(**registrar_options)
for pack in PACKS:
actions_registrar.register_from_pack(pack)
policies_registrar.register_from_pack(pack)
def setUp(self):
super(SchedulerPoliciesTestCase, self).setUp()
# Register runners
runners_registrar.register_runners()
# Register common policy types
register_policy_types(st2common)
loader = FixturesLoader()
models = loader.save_fixtures_to_db(fixtures_pack=PACK,
fixtures_dict=TEST_FIXTURES_2)
# Policy with "post_run" application
self.policy_db = models['policies']['policy_1.yaml']
def setUpClass(cls):
super(WorkflowInspectionControllerTest, cls).setUpClass()
st2tests.WorkflowTestCase.setUpClass()
# Register runners.
runnersregistrar.register_runners()
# Register test pack(s).
actions_registrar = actionsregistrar.ActionsRegistrar(
use_pack_cache=False,
fail_on_failure=True
)
for pack in PACKS:
actions_registrar.register_from_pack(pack)
def register_runners():
# Register runners
runner_dir = cfg.CONF.register.runner_dir
if runner_dir:
runner_dir = [runner_dir]
registered_count = 0
fail_on_failure = cfg.CONF.register.fail_on_failure
# 1. Register runner types
try:
LOG.info('=========================================================')
LOG.info('############## Registering runners ######################')
LOG.info('=========================================================')
registered_count = runners_registrar.register_runners(
runner_dirs=runner_dir,
fail_on_failure=fail_on_failure,
experimental=False)
except Exception as error:
exc_info = not fail_on_failure
# TODO: Narrow exception window
LOG.warning('Failed to register runners: %s', error, exc_info=exc_info)
if fail_on_failure:
raise error
LOG.info('Registered %s runners.', registered_count)
def post(self, pack_register_request):
if pack_register_request and hasattr(pack_register_request, 'types'):
types = pack_register_request.types
if 'all' in types:
types = PackRegisterController.CONTENT_TYPES
else:
types = PackRegisterController.CONTENT_TYPES
if pack_register_request and hasattr(pack_register_request, 'packs'):
packs = list(set(pack_register_request.packs))
else:
packs = None
result = defaultdict(int)
# Register depended resources (actions depend on runners, rules depend on rule types, etc)
if ('runner' in types or 'runners' in types) or ('action' in types or
'actions' in types):
result['runners'] = runners_registrar.register_runners(
experimental=True)
if ('rule_type' in types or 'rule_types' in types) or \
('rule' in types or 'rules' in types):
result['rule_types'] = rule_types_registrar.register_rule_types()
if ('policy_type' in types or 'policy_types' in types) or \
('policy' in types or 'policies' in types):
result['policy_types'] = policies_registrar.register_policy_types(
st2common)
use_pack_cache = False
fail_on_failure = getattr(pack_register_request, 'fail_on_failure',
True)
for type, (Registrar, name) in six.iteritems(ENTITIES):
if type in types or name in types:
registrar = Registrar(use_pack_cache=use_pack_cache,
fail_on_failure=fail_on_failure)
if packs:
for pack in packs:
pack_path = content_utils.get_pack_base_path(pack)
try:
registered_count = registrar.register_from_pack(
pack_dir=pack_path)
result[name] += registered_count
except ValueError as e:
# Throw more user-friendly exception if requsted pack doesn't exist
if re.match('Directory ".*?" doesn\'t exist',
str(e)):
msg = 'Pack "%s" not found on disk: %s' % (
pack, str(e))
raise ValueError(msg)
raise e
else:
packs_base_paths = content_utils.get_packs_base_paths()
registered_count = registrar.register_from_packs(
base_dirs=packs_base_paths)
result[name] += registered_count
return result
def setUpClass(cls):
EventletTestCase.setUpClass()
ExecutionDbTestCase.setUpClass()
# Override the coordinator to use the noop driver otherwise the tests will be blocked.
tests_config.parse_args(coordinator_noop=True)
coordination.COORDINATOR = None
# Register runners
runners_registrar.register_runners()
# Register common policy types
register_policy_types(st2common)
loader = FixturesLoader()
loader.save_fixtures_to_db(fixtures_pack=PACK, fixtures_dict=TEST_FIXTURES)
def register_runners():
# Register runners
runner_dir = cfg.CONF.register.runner_dir
if runner_dir:
runner_dir = [runner_dir]
registered_count = 0
fail_on_failure = cfg.CONF.register.fail_on_failure
# 1. Register runner types
try:
LOG.info('=========================================================')
LOG.info('############## Registering runners ######################')
LOG.info('=========================================================')
registered_count = runners_registrar.register_runners(runner_dirs=runner_dir,
fail_on_failure=fail_on_failure,
experimental=False)
except Exception as error:
exc_info = not fail_on_failure
# TODO: Narrow exception window
LOG.warning('Failed to register runners: %s', error, exc_info=exc_info)
if fail_on_failure:
raise error
LOG.info('Registered %s runners.', registered_count)
def setUpClass(cls):
super(MistralRunnerTest, cls).setUpClass()
cfg.CONF.set_override('api_url', 'http://0.0.0.0:9101', group='auth')
# Register runners.
runnersregistrar.register_runners()
# Register test pack(s).
actions_registrar = actionsregistrar.ActionsRegistrar(
use_pack_cache=False,
fail_on_failure=True
)
for pack in PACKS:
actions_registrar.register_from_pack(pack)
def setUpClass(cls):
super(ActionParamsUtilsTest, cls).setUpClass()
runners_registrar.register_runners()
cls.runnertype_dbs = {}
cls.action_dbs = {}
for _, fixture in six.iteritems(FIXTURES['runners']):
instance = RunnerTypeAPI(**fixture)
runnertype_db = RunnerType.add_or_update(RunnerTypeAPI.to_model(instance))
cls.runnertype_dbs[runnertype_db.name] = runnertype_db
for _, fixture in six.iteritems(FIXTURES['actions']):
instance = ActionAPI(**fixture)
action_db = Action.add_or_update(ActionAPI.to_model(instance))
cls.action_dbs[action_db.name] = action_db
def setUpClass(cls):
EventletTestCase.setUpClass()
DbTestCase.setUpClass()
# Override the coordinator to use the noop driver otherwise the tests will be blocked.
tests_config.parse_args(coordinator_noop=True)
coordination.COORDINATOR = None
# Register runners
runners_registrar.register_runners()
# Register common policy types
register_policy_types(st2common)
loader = FixturesLoader()
loader.save_fixtures_to_db(fixtures_pack=PACK,
fixtures_dict=TEST_FIXTURES)
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(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()
runners_registrar.register_runners()
cls.runnertype_dbs = {}
cls.action_dbs = {}
for _, fixture in six.iteritems(FIXTURES['runners']):
instance = RunnerTypeAPI(**fixture)
runnertype_db = RunnerType.add_or_update(
RunnerTypeAPI.to_model(instance))
cls.runnertype_dbs[runnertype_db.name] = runnertype_db
for _, fixture in six.iteritems(FIXTURES['actions']):
instance = ActionAPI(**fixture)
action_db = Action.add_or_update(ActionAPI.to_model(instance))
cls.action_dbs[action_db.name] = action_db
def setUpClass(cls):
super(MistralRunnerCancelTest, cls).setUpClass()
# Override the retry configuration here otherwise st2tests.config.parse_args
# in DbTestCase.setUpClass will reset these overrides.
cfg.CONF.set_override('retry_exp_msec', 100, group='mistral')
cfg.CONF.set_override('retry_exp_max_msec', 200, group='mistral')
cfg.CONF.set_override('retry_stop_max_msec', 200, group='mistral')
cfg.CONF.set_override('api_url', 'http://0.0.0.0:9101', group='auth')
# Register runners.
runnersregistrar.register_runners()
# Register test pack(s).
actions_registrar = actionsregistrar.ActionsRegistrar(
use_pack_cache=False, fail_on_failure=True)
for pack in PACKS:
actions_registrar.register_from_pack(pack)
def setUpClass(cls):
super(MistralAuthTest, cls).setUpClass()
# Override the retry configuration here otherwise st2tests.config.parse_args
# in DbTestCase.setUpClass will reset these overrides.
cfg.CONF.set_override('retry_exp_msec', 100, group='mistral')
cfg.CONF.set_override('retry_exp_max_msec', 200, group='mistral')
cfg.CONF.set_override('retry_stop_max_msec', 200, group='mistral')
# Register runners.
runners_registrar.register_runners()
# Register test pack(s).
registrar = actionsregistrar.ActionsRegistrar(
use_pack_cache=False,
fail_on_failure=True
)
for pack in PACKS:
registrar.register_from_pack(pack)
def post(self, pack_register_request):
if pack_register_request and hasattr(pack_register_request, 'types'):
types = pack_register_request.types
if 'all' in types:
types = PackRegisterController.CONTENT_TYPES
else:
types = PackRegisterController.CONTENT_TYPES
if pack_register_request and hasattr(pack_register_request, 'packs'):
packs = list(set(pack_register_request.packs))
else:
packs = None
result = defaultdict(int)
# Register depended resources (actions depend on runners, rules depend on rule types, etc)
if ('runner' in types or 'runners' in types) or ('action' in types or 'actions' in types):
result['runners'] = runners_registrar.register_runners(experimental=True)
if ('rule_type' in types or 'rule_types' in types) or \
('rule' in types or 'rules' in types):
result['rule_types'] = rule_types_registrar.register_rule_types()
if ('policy_type' in types or 'policy_types' in types) or \
('policy' in types or 'policies' in types):
result['policy_types'] = policies_registrar.register_policy_types(st2common)
use_pack_cache = False
fail_on_failure = getattr(pack_register_request, 'fail_on_failure', True)
for type, (Registrar, name) in six.iteritems(ENTITIES):
if type in types or name in types:
registrar = Registrar(use_pack_cache=use_pack_cache,
use_runners_cache=True,
fail_on_failure=fail_on_failure)
if packs:
for pack in packs:
pack_path = content_utils.get_pack_base_path(pack)
try:
registered_count = registrar.register_from_pack(pack_dir=pack_path)
result[name] += registered_count
except ValueError as e:
# Throw more user-friendly exception if requsted pack doesn't exist
if re.match('Directory ".*?" doesn\'t exist', six.text_type(e)):
msg = 'Pack "%s" not found on disk: %s' % (pack, six.text_type(e))
raise ValueError(msg)
raise e
else:
packs_base_paths = content_utils.get_packs_base_paths()
registered_count = registrar.register_from_packs(base_dirs=packs_base_paths)
result[name] += registered_count
return result
def setUpClass(cls):
super(MistralRunnerCancelTest, cls).setUpClass()
# Override the retry configuration here otherwise st2tests.config.parse_args
# in ExecutionDbTestCas.setUpClass will reset these overrides.
cfg.CONF.set_override('retry_exp_msec', 100, group='mistral')
cfg.CONF.set_override('retry_exp_max_msec', 200, group='mistral')
cfg.CONF.set_override('retry_stop_max_msec', 200, group='mistral')
cfg.CONF.set_override('api_url', 'http://0.0.0.0:9101', group='auth')
# Register runners.
runnersregistrar.register_runners()
# Register test pack(s).
actions_registrar = actionsregistrar.ActionsRegistrar(
use_pack_cache=False,
fail_on_failure=True
)
for pack in PACKS:
actions_registrar.register_from_pack(pack)
def setUp(self):
super(RetryPolicyTestCase, self).setUp()
# Register runners
runners_registrar.register_runners()
# Register common policy types
register_policy_types(st2actions)
loader = FixturesLoader()
models = loader.save_fixtures_to_db(fixtures_pack=PACK,
fixtures_dict=TEST_FIXTURES)
# Instantiate policy applicator we will use in the tests
policy_db = models['policies']['policy_4.yaml']
retry_on = policy_db.parameters['retry_on']
max_retry_count = policy_db.parameters['max_retry_count']
self.policy = ExecutionRetryPolicyApplicator(policy_ref='test_policy',
policy_type='action.retry',
retry_on=retry_on,
max_retry_count=max_retry_count,
delay=0)
def setUp(self):
super(RetryPolicyTestCase, self).setUp()
# Register runners
runners_registrar.register_runners()
# Register common policy types
register_policy_types(st2actions)
loader = FixturesLoader()
models = loader.save_fixtures_to_db(fixtures_pack=PACK,
fixtures_dict=TEST_FIXTURES)
# Instantiate policy applicator we will use in the tests
policy_db = models['policies']['policy_4.yaml']
retry_on = policy_db.parameters['retry_on']
max_retry_count = policy_db.parameters['max_retry_count']
self.policy = ExecutionRetryPolicyApplicator(policy_ref='test_policy',
policy_type='action.retry',
retry_on=retry_on,
max_retry_count=max_retry_count,
delay=0)
def post(self, pack_register_request):
if pack_register_request and hasattr(pack_register_request, 'types'):
types = pack_register_request.types
else:
types = [
'runner', 'action', 'trigger', 'sensor', 'rule', 'rule_type',
'alias', 'policy_type', 'policy', 'config'
]
if pack_register_request and hasattr(pack_register_request, 'packs'):
packs = pack_register_request.packs
else:
packs = None
result = {}
if 'runner' in types or 'action' in types:
result['runners'] = runners_registrar.register_runners(
experimental=True)
if 'rule_type' in types or 'rule' in types:
result['rule_types'] = rule_types_registrar.register_rule_types()
if 'policy_type' in types or 'policy' in types:
result['policy_types'] = policies_registrar.register_policy_types(
st2common)
use_pack_cache = False
for type, (Registrar, name) in six.iteritems(ENTITIES):
if type in types:
registrar = Registrar(use_pack_cache=use_pack_cache,
fail_on_failure=False)
if packs:
for pack in packs:
pack_path = content_utils.get_pack_base_path(pack)
result[name] = registrar.register_from_pack(
pack_dir=pack_path)
else:
packs_base_paths = content_utils.get_packs_base_paths()
result[name] = registrar.register_from_packs(
base_dirs=packs_base_paths)
return result
def register_runners():
# Register runners
registered_count = 0
fail_on_failure = cfg.CONF.register.fail_on_failure
# 1. Register runner types
try:
LOG.info("=========================================================")
LOG.info("############## Registering runners ######################")
LOG.info("=========================================================")
with Timer(key="st2.register.runners"):
registered_count = runners_registrar.register_runners(
fail_on_failure=fail_on_failure, experimental=False)
except Exception as error:
exc_info = not fail_on_failure
# TODO: Narrow exception window
LOG.warning("Failed to register runners: %s", error, exc_info=exc_info)
if fail_on_failure:
raise error
LOG.info("Registered %s runners.", registered_count)
def post(self, pack_register_request):
if pack_register_request and hasattr(pack_register_request, 'types'):
types = pack_register_request.types
else:
types = ['runner', 'action', 'trigger', 'sensor', 'rule', 'rule_type', 'alias',
'policy_type', 'policy', 'config']
if pack_register_request and hasattr(pack_register_request, 'packs'):
packs = pack_register_request.packs
else:
packs = None
result = {}
if 'runner' in types or 'action' in types:
result['runners'] = runners_registrar.register_runners(experimental=True)
if 'rule_type' in types or 'rule' in types:
result['rule_types'] = rule_types_registrar.register_rule_types()
if 'policy_type' in types or 'policy' in types:
result['policy_types'] = policies_registrar.register_policy_types(st2common)
use_pack_cache = False
for type, (Registrar, name) in six.iteritems(ENTITIES):
if type in types:
registrar = Registrar(use_pack_cache=use_pack_cache,
fail_on_failure=False)
if packs:
for pack in packs:
pack_path = content_utils.get_pack_base_path(pack)
result[name] = registrar.register_from_pack(pack_dir=pack_path)
else:
packs_base_paths = content_utils.get_packs_base_paths()
result[name] = registrar.register_from_packs(base_dirs=packs_base_paths)
return result
def setup(service, config, setup_db=True, register_mq_exchanges=True,
register_signal_handlers=True, register_internal_trigger_types=False,
run_migrations=True, register_runners=True, service_registry=False,
capabilities=None, config_args=None):
"""
Common setup function.
Currently it performs the following operations:
1. Parses config and CLI arguments
2. Establishes DB connection
3. Set log level for all the loggers to DEBUG if --debug flag is present or
if system.debug config option is set to True.
4. Registers RabbitMQ exchanges
5. Registers common signal handlers
6. Register internal trigger types
7. Register all the runners which are installed inside StackStorm virtualenv.
8. Register service in the service registry with the provided capabilities
:param service: Name of the service.
:param config: Config object to use to parse args.
"""
capabilities = capabilities or {}
# Set up logger which logs everything which happens during and before config
# parsing to sys.stdout
logging.setup(DEFAULT_LOGGING_CONF_PATH, excludes=None)
# Parse args to setup config.
if config_args is not None:
config.parse_args(config_args)
else:
config.parse_args()
version = '%s.%s.%s' % (sys.version_info[0], sys.version_info[1], sys.version_info[2])
LOG.debug('Using Python: %s (%s)' % (version, sys.executable))
config_file_paths = cfg.CONF.config_file
config_file_paths = [os.path.abspath(path) for path in config_file_paths]
LOG.debug('Using config files: %s', ','.join(config_file_paths))
# Setup logging.
logging_config_path = config.get_logging_config_path()
logging_config_path = os.path.abspath(logging_config_path)
LOG.debug('Using logging config: %s', logging_config_path)
is_debug_enabled = (cfg.CONF.debug or cfg.CONF.system.debug)
try:
logging.setup(logging_config_path, redirect_stderr=cfg.CONF.log.redirect_stderr,
excludes=cfg.CONF.log.excludes)
except KeyError as e:
tb_msg = traceback.format_exc()
if 'log.setLevel' in tb_msg:
msg = 'Invalid log level selected. Log level names need to be all uppercase.'
msg += '\n\n' + getattr(e, 'message', six.text_type(e))
raise KeyError(msg)
else:
raise e
exclude_log_levels = [stdlib_logging.AUDIT]
handlers = stdlib_logging.getLoggerClass().manager.root.handlers
for handler in handlers:
# If log level is not set to DEBUG we filter out "AUDIT" log messages. This way we avoid
# duplicate "AUDIT" messages in production deployments where default service log level is
# set to "INFO" and we already log messages with level AUDIT to a special dedicated log
# file.
ignore_audit_log_messages = (handler.level >= stdlib_logging.INFO and
handler.level < stdlib_logging.AUDIT)
if not is_debug_enabled and ignore_audit_log_messages:
LOG.debug('Excluding log messages with level "AUDIT" for handler "%s"' % (handler))
handler.addFilter(LogLevelFilter(log_levels=exclude_log_levels))
if not is_debug_enabled:
# NOTE: statsd logger logs everything by default under INFO so we ignore those log
# messages unless verbose / debug mode is used
logging.ignore_statsd_log_messages()
logging.ignore_lib2to3_log_messages()
if is_debug_enabled:
enable_debugging()
else:
# Add global ignore filters, such as "heartbeat_tick" messages which are logged every 2
# ms which cause too much noise
add_global_filters_for_all_loggers()
if cfg.CONF.profile:
enable_profiling()
# All other setup which requires config to be parsed and logging to be correctly setup.
if setup_db:
db_setup()
if register_mq_exchanges:
register_exchanges_with_retry()
if register_signal_handlers:
register_common_signal_handlers()
if register_internal_trigger_types:
triggers.register_internal_trigger_types()
# TODO: This is a "not so nice" workaround until we have a proper migration system in place
if run_migrations:
run_all_rbac_migrations()
if register_runners:
runnersregistrar.register_runners()
register_kombu_serializers()
metrics_initialize()
# Register service in the service registry
if cfg.CONF.coordination.service_registry and service_registry:
# NOTE: It's important that we pass start_heart=True to start the hearbeat process
register_service_in_service_registry(service=service, capabilities=capabilities,
start_heart=True)
def setup(service,
config,
setup_db=True,
register_mq_exchanges=True,
register_signal_handlers=True,
register_internal_trigger_types=False,
run_migrations=True,
register_runners=True,
config_args=None):
"""
Common setup function.
Currently it performs the following operations:
1. Parses config and CLI arguments
2. Establishes DB connection
3. Set log level for all the loggers to DEBUG if --debug flag is present or
if system.debug config option is set to True.
4. Registers RabbitMQ exchanges
5. Registers common signal handlers
6. Register internal trigger types
7. Register all the runners which are installed inside StackStorm virtualenv.
:param service: Name of the service.
:param config: Config object to use to parse args.
"""
# Set up logger which logs everything which happens during and before config
# parsing to sys.stdout
logging.setup(DEFAULT_LOGGING_CONF_PATH, excludes=None)
# Parse args to setup config.
if config_args:
config.parse_args(config_args)
else:
config.parse_args()
version = '%s.%s.%s' % (sys.version_info[0], sys.version_info[1],
sys.version_info[2])
LOG.debug('Using Python: %s (%s)' % (version, sys.executable))
config_file_paths = cfg.CONF.config_file
config_file_paths = [os.path.abspath(path) for path in config_file_paths]
LOG.debug('Using config files: %s', ','.join(config_file_paths))
# Setup logging.
logging_config_path = config.get_logging_config_path()
logging_config_path = os.path.abspath(logging_config_path)
LOG.debug('Using logging config: %s', logging_config_path)
is_debug_enabled = (cfg.CONF.debug or cfg.CONF.system.debug)
try:
logging.setup(logging_config_path,
redirect_stderr=cfg.CONF.log.redirect_stderr,
excludes=cfg.CONF.log.excludes)
except KeyError as e:
tb_msg = traceback.format_exc()
if 'log.setLevel' in tb_msg:
msg = 'Invalid log level selected. Log level names need to be all uppercase.'
msg += '\n\n' + getattr(e, 'message', str(e))
raise KeyError(msg)
else:
raise e
exclude_log_levels = [stdlib_logging.AUDIT]
handlers = stdlib_logging.getLoggerClass().manager.root.handlers
for handler in handlers:
# If log level is not set to DEBUG we filter out "AUDIT" log messages. This way we avoid
# duplicate "AUDIT" messages in production deployments where default service log level is
# set to "INFO" and we already log messages with level AUDIT to a special dedicated log
# file.
ignore_audit_log_messages = (handler.level >= stdlib_logging.INFO
and handler.level < stdlib_logging.AUDIT)
if not is_debug_enabled and ignore_audit_log_messages:
LOG.debug(
'Excluding log messages with level "AUDIT" for handler "%s"' %
(handler))
handler.addFilter(LogLevelFilter(log_levels=exclude_log_levels))
if not is_debug_enabled:
# NOTE: statsd logger logs everything by default under INFO so we ignore those log
# messages unless verbose / debug mode is used
logging.ignore_statsd_log_messages()
logging.ignore_lib2to3_log_messages()
if is_debug_enabled:
enable_debugging()
else:
# Add global ignore filters, such as "heartbeat_tick" messages which are logged every 2
# ms which cause too much noise
add_global_filters_for_all_loggers()
if cfg.CONF.profile:
enable_profiling()
# All other setup which requires config to be parsed and logging to be correctly setup.
if setup_db:
db_setup()
if register_mq_exchanges:
register_exchanges_with_retry()
if register_signal_handlers:
register_common_signal_handlers()
if register_internal_trigger_types:
triggers.register_internal_trigger_types()
# TODO: This is a "not so nice" workaround until we have a proper migration system in place
if run_migrations:
run_all_rbac_migrations()
if register_runners:
runnersregistrar.register_runners()
register_kombu_serializers()
metrics_initialize()
def setUp(self):
super(ActionExecutionRBACControllerTestCase, self).setUp()
runners_registrar.register_runners()
self.fixtures_loader.save_fixtures_to_db(fixtures_pack=FIXTURES_PACK,
fixtures_dict=TEST_FIXTURES)
# Insert mock users, roles and assignments
# Users
user_1_db = UserDB(name='multiple_roles')
user_1_db = User.add_or_update(user_1_db)
self.users['multiple_roles'] = user_1_db
user_2_db = UserDB(name='user_two')
user_2_db = User.add_or_update(user_2_db)
self.users['user_two'] = user_2_db
user_3_db = UserDB(name='user_three')
user_3_db = User.add_or_update(user_3_db)
self.users['user_three'] = user_3_db
# Roles
roles = ['role_1', 'role_2', 'role_3']
for role in roles:
role_db = RoleDB(name=role)
Role.add_or_update(role_db)
# action_execute, execution_list on parent pack
# action_view on parent pack
grant_1_db = PermissionGrantDB(resource_uid='pack:wolfpack',
resource_type=ResourceType.PACK,
permission_types=[
PermissionType.ACTION_EXECUTE,
PermissionType.ACTION_VIEW
])
grant_1_db = PermissionGrant.add_or_update(grant_1_db)
grant_2_db = PermissionGrantDB(
resource_uid=None,
resource_type=ResourceType.EXECUTION,
permission_types=[PermissionType.EXECUTION_LIST])
grant_2_db = PermissionGrant.add_or_update(grant_2_db)
permission_grants = [str(grant_1_db.id), str(grant_2_db.id)]
role_1_db = RoleDB(name='role_4', permission_grants=permission_grants)
role_1_db = Role.add_or_update(role_1_db)
self.roles['role_4'] = role_1_db
# Role assignments
role_assignment_db = UserRoleAssignmentDB(
user=user_1_db.name,
role='admin',
source='assignments/%s.yaml' % user_1_db.name)
UserRoleAssignment.add_or_update(role_assignment_db)
for role in roles:
role_assignment_db = UserRoleAssignmentDB(
user=user_1_db.name,
role=role,
source='assignments/%s.yaml' % user_1_db.name)
UserRoleAssignment.add_or_update(role_assignment_db)
role_assignment_db = UserRoleAssignmentDB(
user=user_2_db.name,
role='role_4',
source='assignments/%s.yaml' % user_2_db.name)
UserRoleAssignment.add_or_update(role_assignment_db)
role_assignment_db = UserRoleAssignmentDB(
user=user_3_db.name,
role='role_4',
source='assignments/%s.yaml' % user_2_db.name)
UserRoleAssignment.add_or_update(role_assignment_db)
def setUp(self):
super(ActionExecutionRBACControllerTestCase, self).setUp()
runners_registrar.register_runners()
self.fixtures_loader.save_fixtures_to_db(fixtures_pack=FIXTURES_PACK,
fixtures_dict=TEST_FIXTURES)
# Insert mock users, roles and assignments
# Users
user_1_db = UserDB(name='multiple_roles')
user_1_db = User.add_or_update(user_1_db)
self.users['multiple_roles'] = user_1_db
user_2_db = UserDB(name='user_two')
user_2_db = User.add_or_update(user_2_db)
self.users['user_two'] = user_2_db
user_3_db = UserDB(name='user_three')
user_3_db = User.add_or_update(user_3_db)
self.users['user_three'] = user_3_db
# Roles
roles = ['role_1', 'role_2', 'role_3']
for role in roles:
role_db = RoleDB(name=role)
Role.add_or_update(role_db)
# action_execute, execution_list on parent pack
# action_view on parent pack
grant_1_db = PermissionGrantDB(resource_uid='pack:wolfpack',
resource_type=ResourceType.PACK,
permission_types=[PermissionType.ACTION_EXECUTE,
PermissionType.ACTION_VIEW])
grant_1_db = PermissionGrant.add_or_update(grant_1_db)
grant_2_db = PermissionGrantDB(resource_uid=None,
resource_type=ResourceType.EXECUTION,
permission_types=[PermissionType.EXECUTION_LIST])
grant_2_db = PermissionGrant.add_or_update(grant_2_db)
permission_grants = [str(grant_1_db.id), str(grant_2_db.id)]
role_1_db = RoleDB(name='role_4', permission_grants=permission_grants)
role_1_db = Role.add_or_update(role_1_db)
self.roles['role_4'] = role_1_db
# Role assignments
role_assignment_db = UserRoleAssignmentDB(
user=user_1_db.name,
role='admin',
source='assignments/%s.yaml' % user_1_db.name)
UserRoleAssignment.add_or_update(role_assignment_db)
for role in roles:
role_assignment_db = UserRoleAssignmentDB(
user=user_1_db.name,
role=role,
source='assignments/%s.yaml' % user_1_db.name)
UserRoleAssignment.add_or_update(role_assignment_db)
role_assignment_db = UserRoleAssignmentDB(
user=user_2_db.name,
role='role_4',
source='assignments/%s.yaml' % user_2_db.name)
UserRoleAssignment.add_or_update(role_assignment_db)
role_assignment_db = UserRoleAssignmentDB(
user=user_3_db.name,
role='role_4',
source='assignments/%s.yaml' % user_2_db.name)
UserRoleAssignment.add_or_update(role_assignment_db)
def setUpClass(cls):
super(TestActionAPIValidator, cls).setUpClass()
runners_registrar.register_runners()
def setUpClass(cls):
super(ExecutionCancellationTest, cls).setUpClass()
runners_registrar.register_runners()
action_local = ActionAPI(**copy.deepcopy(fixture.ARTIFACTS['actions']['local']))
Action.add_or_update(ActionAPI.to_model(action_local))
def setUpClass(cls):
super(TestActionAPIValidator, cls).setUpClass()
runners_registrar.register_runners()
