def test_workflow_without_auth(self):
cfg.CONF.set_default('auth_enable', False, group='pecan')
wf = workflows.create_workflows(WORKFLOW_LIST)[0]
triggers.create_cron_trigger(
'trigger-%s' % utils.generate_unicode_uuid(), wf.name, {}, {},
'* * * * * */1', None, None, None)
next_triggers = triggers.get_next_cron_triggers()
self.assertEqual(1, len(next_triggers))
next_trigger = next_triggers[0]
next_execution_time_before = next_trigger.next_execution_time
periodic.MistralPeriodicTasks(cfg.CONF).process_cron_triggers_v2(None)
next_triggers = triggers.get_next_cron_triggers()
self.assertEqual(1, len(next_triggers))
next_trigger = next_triggers[0]
next_execution_time_after = next_trigger.next_execution_time
self.assertNotEqual(next_execution_time_before,
next_execution_time_after)
def test_start_workflow(self, rpc_mock):
cfg.CONF.set_default('auth_enable', True, group='pecan')
wf = workflows.create_workflows(WORKFLOW_LIST)[0]
t = triggers.create_cron_trigger(
'trigger-%s' % utils.generate_unicode_uuid(), wf.name, {}, {},
'* * * * * */1', None, None, None)
self.assertEqual('my_trust_id', t.trust_id)
cfg.CONF.set_default('auth_enable', False, group='pecan')
next_trigger = triggers.get_next_cron_triggers()[0]
next_execution_time_before = next_trigger.next_execution_time
periodic.MistralPeriodicTasks(cfg.CONF).process_cron_triggers_v2(None)
start_workflow_mock = rpc_mock.return_value.start_workflow
start_workflow_mock.assert_called_once()
self.assertIn(t.id,
start_workflow_mock.mock_calls[0][2]['description'])
next_triggers = triggers.get_next_cron_triggers()
self.assertEqual(1, len(next_triggers))
next_trigger = next_triggers[0]
next_execution_time_after = next_trigger.next_execution_time
# Checking the workflow was executed, by
# verifying that the next execution time changed.
self.assertNotEqual(next_execution_time_before,
next_execution_time_after)
def test_start_workflow(self):
cfg.CONF.set_default('auth_enable', True, group='pecan')
wf = workflows.create_workflows(WORKFLOW_LIST)[0]
t = t_s.create_cron_trigger(
'test',
wf.name,
{},
{},
'* * * * * */1',
None,
None,
None
)
self.assertEqual('my_trust_id', t.trust_id)
cfg.CONF.set_default('auth_enable', False, group='pecan')
m_p_t = periodic.MistralPeriodicTasks(cfg.CONF)
next_cron_trigger = t_s.get_next_cron_triggers()[0]
next_execution_before = next_cron_trigger.next_execution_time
m_p_t.process_cron_triggers_v2(None)
next_cron_trigger = t_s.get_next_cron_triggers()[0]
next_execution_after = next_cron_trigger.next_execution_time
# Checking the workflow was executed, by
# verifying that the next execution time changed.
self.assertNotEqual(next_execution_before, next_execution_after)
def test_workflow_without_auth(self):
cfg.CONF.set_default('auth_enable', False, group='pecan')
wf = workflows.create_workflows(WORKFLOW_LIST)[0]
triggers.create_cron_trigger(
'trigger-%s' % utils.generate_unicode_uuid(), wf.name, {}, {},
'* * * * * */1', None, None, None)
next_triggers = triggers.get_next_cron_triggers()
self.assertEqual(1, len(next_triggers))
next_trigger = next_triggers[0]
next_execution_time_before = next_trigger.next_execution_time
ts_before = datetime.datetime.utcnow()
periodic.process_cron_triggers_v2(None, None)
self._await(lambda: triggers.get_next_cron_triggers(),
fail_message="No triggers were found")
next_triggers = triggers.get_next_cron_triggers()
self.assertEqual(1, len(next_triggers))
next_trigger = next_triggers[0]
next_execution_time_after = next_trigger.next_execution_time
self.assertGreater(next_execution_time_after, ts_before)
self.assertNotEqual(next_execution_time_before,
next_execution_time_after)
def test_start_workflow(self):
cfg.CONF.set_default('auth_enable', True, group='pecan')
wf = workflows.create_workflows(WORKFLOW_LIST)[0]
t = triggers.create_cron_trigger(
'test',
wf.name,
{},
{},
'* * * * * */1',
None,
None,
None
)
self.assertEqual('my_trust_id', t.trust_id)
cfg.CONF.set_default('auth_enable', False, group='pecan')
next_trigger = triggers.get_next_cron_triggers()[0]
next_execution_time_before = next_trigger.next_execution_time
periodic.MistralPeriodicTasks(cfg.CONF).process_cron_triggers_v2(None)
next_trigger = triggers.get_next_cron_triggers()[0]
next_execution_time_after = next_trigger.next_execution_time
# Checking the workflow was executed, by
# verifying that the next execution time changed.
self.assertNotEqual(
next_execution_time_before,
next_execution_time_after
)
def test_start_workflow(self, get_engine_client_mock):
cfg.CONF.set_default('auth_enable', True, group='pecan')
wf = workflows.create_workflows(WORKFLOW_LIST)[0]
t = triggers.create_cron_trigger(
'trigger-%s' % utils.generate_unicode_uuid(),
wf.name,
{},
{},
'* * * * * */1',
None,
None,
None
)
self.assertEqual('my_trust_id', t.trust_id)
cfg.CONF.set_default('auth_enable', False, group='pecan')
next_trigger = triggers.get_next_cron_triggers()[0]
next_execution_time_before = next_trigger.next_execution_time
periodic.process_cron_triggers_v2(None, None)
start_wf_mock = get_engine_client_mock.return_value.start_workflow
start_wf_mock.assert_called_once()
# Check actual parameters of the call.
self.assertEqual(
('my_wf', '', None, {}),
start_wf_mock.mock_calls[0][1]
)
self.assertIn(
t.id,
start_wf_mock.mock_calls[0][2]['description']
)
self._await(
lambda: triggers.get_next_cron_triggers(),
fail_message="No triggers were found"
)
next_triggers = triggers.get_next_cron_triggers()
self.assertEqual(1, len(next_triggers))
next_trigger = next_triggers[0]
next_execution_time_after = next_trigger.next_execution_time
# Checking the workflow was executed, by
# verifying that the next execution time changed.
self.assertNotEqual(
next_execution_time_before,
next_execution_time_after
)
def process_cron_triggers_v2(self, ctx):
for t in triggers.get_next_cron_triggers():
LOG.debug("Processing cron trigger: %s" % t)
# Setup admin context before schedule triggers.
ctx = security.create_context(t.trust_id, t.project_id)
auth_ctx.set_ctx(ctx)
LOG.debug("Cron trigger security context: %s" % ctx)
try:
rpc.get_engine_client().start_workflow(
t.workflow.name,
t.workflow_input,
description="Workflow execution created by cron trigger.",
**t.workflow_params
)
finally:
if t.remaining_executions is not None and t.remaining_executions > 0:
t.remaining_executions -= 1
if t.remaining_executions == 0:
db_api_v2.delete_cron_trigger(t.name)
else: # if remaining execution = None or > 0
next_time = triggers.get_next_execution_time(t.pattern, t.next_execution_time)
db_api_v2.update_cron_trigger(
t.name, {"next_execution_time": next_time, "remaining_executions": t.remaining_executions}
)
auth_ctx.set_ctx(None)
def test_get_trigger_in_correct_orders(self):
t1_name = 'trigger-%s' % utils.generate_unicode_uuid()
t_s.create_cron_trigger(t1_name,
self.wf.name, {},
pattern='*/5 * * * *',
start_time=datetime.datetime(2010, 8, 25))
t2_name = 'trigger-%s' % utils.generate_unicode_uuid()
t_s.create_cron_trigger(t2_name,
self.wf.name, {},
pattern='*/1 * * * *',
start_time=datetime.datetime(2010, 8, 22))
t3_name = 'trigger-%s' % utils.generate_unicode_uuid()
t_s.create_cron_trigger(t3_name,
self.wf.name, {},
pattern='*/2 * * * *',
start_time=datetime.datetime(2010, 9, 21))
t4_name = 'trigger-%s' % utils.generate_unicode_uuid()
t_s.create_cron_trigger(t4_name,
self.wf.name, {},
pattern='*/3 * * * *',
start_time=datetime.datetime.utcnow() +
datetime.timedelta(0, 50))
trigger_names = [t.name for t in t_s.get_next_cron_triggers()]
self.assertEqual([t2_name, t1_name, t3_name], trigger_names)
def process_cron_triggers_v2(self, ctx):
for t in triggers.get_next_cron_triggers():
LOG.debug("Processing cron trigger: %s" % t)
# Setup admin context before schedule triggers.
ctx = security.create_context(t.trust_id, t.project_id)
auth_ctx.set_ctx(ctx)
LOG.debug("Cron trigger security context: %s" % ctx)
try:
rpc.get_engine_client().start_workflow(
t.workflow.name,
t.workflow_input,
description="workflow execution by cron trigger.",
**t.workflow_params
)
finally:
if t.remaining_executions > 0:
t.remaining_executions -= 1
if t.remaining_executions == 0:
db_api_v2.delete_cron_trigger(t.name)
else: # if remaining execution = None or > 0
next_time = triggers.get_next_execution_time(
t.pattern,
t.next_execution_time
)
db_api_v2.update_cron_trigger(
t.name,
{'next_execution_time': next_time,
'remaining_executions': t.remaining_executions}
)
auth_ctx.set_ctx(None)
def process_cron_triggers_v2(self, ctx):
for t in triggers.get_next_cron_triggers():
LOG.debug("Processing cron trigger: %s" % t)
# Setup admin context before schedule triggers.
ctx = security.create_context(t.trust_id, t.project_id)
auth_ctx.set_ctx(ctx)
LOG.debug("Cron trigger security context: %s" % ctx)
try:
# Try to advance the cron trigger next_execution_time and
# remaining_executions if relevant.
modified = advance_cron_trigger(t)
# If cron trigger was not already modified by another engine.
if modified:
LOG.debug(
"Starting workflow '%s' by cron trigger '%s'",
t.workflow.name, t.name
)
rpc.get_engine_client().start_workflow(
t.workflow.name,
t.workflow_input,
description="Workflow execution created "
"by cron trigger.",
**t.workflow_params
)
except Exception:
# Log and continue to next cron trigger.
LOG.exception("Failed to process cron trigger %s" % str(t))
finally:
auth_ctx.set_ctx(None)
def test_workflow_without_auth(self):
cfg.CONF.set_default('auth_enable', False, group='pecan')
wf = workflows.create_workflows(WORKFLOW_LIST)[0]
triggers.create_cron_trigger(
'trigger-%s' % utils.generate_unicode_uuid(),
wf.name,
{},
{},
'* * * * * */1',
None,
None,
None
)
next_triggers = triggers.get_next_cron_triggers()
self.assertEqual(1, len(next_triggers))
next_trigger = next_triggers[0]
next_execution_time_before = next_trigger.next_execution_time
ts_before = datetime.datetime.utcnow()
periodic.process_cron_triggers_v2(None, None)
self._await(
lambda: triggers.get_next_cron_triggers(),
fail_message="No triggers were found"
)
next_triggers = triggers.get_next_cron_triggers()
self.assertEqual(1, len(next_triggers))
next_trigger = next_triggers[0]
next_execution_time_after = next_trigger.next_execution_time
self.assertGreater(
next_execution_time_after,
ts_before
)
self.assertNotEqual(
next_execution_time_before,
next_execution_time_after
)
def process_cron_triggers_v2(self, ctx):
LOG.debug("Processing cron triggers...")
for trigger in triggers.get_next_cron_triggers():
LOG.debug("Processing cron trigger: %s", trigger)
try:
# Setup admin context before schedule triggers.
ctx = security.create_context(
trigger.trust_id,
trigger.project_id
)
auth_ctx.set_ctx(ctx)
LOG.debug("Cron trigger security context: %s", ctx)
# Try to advance the cron trigger next_execution_time and
# remaining_executions if relevant.
modified = advance_cron_trigger(trigger)
# If cron trigger was not already modified by another engine.
if modified:
LOG.debug(
"Starting workflow '%s' by cron trigger '%s'",
trigger.workflow.name,
trigger.name
)
description = {
"description": (
"Workflow execution created by cron"
" trigger '(%s)'." % trigger.id
),
"triggered_by": {
"type": "cron_trigger",
"id": trigger.id,
"name": trigger.name,
}
}
rpc.get_engine_client().start_workflow(
trigger.workflow.name,
trigger.workflow.namespace,
None,
trigger.workflow_input,
description=json.dumps(description),
**trigger.workflow_params
)
except Exception:
# Log and continue to next cron trigger.
LOG.exception(
"Failed to process cron trigger %s",
str(trigger)
)
finally:
auth_ctx.set_ctx(None)
def test_get_trigger_in_correct_orders(self):
t1_name = 'trigger-%s' % utils.generate_unicode_uuid()
t_s.create_cron_trigger(
t1_name,
self.wf.name,
{},
{},
'*/5 * * * *',
None,
None,
datetime.datetime(2010, 8, 25)
)
t2_name = 'trigger-%s' % utils.generate_unicode_uuid()
t_s.create_cron_trigger(
t2_name,
self.wf.name,
{},
{},
'*/1 * * * *',
None,
None,
datetime.datetime(2010, 8, 22)
)
t3_name = 'trigger-%s' % utils.generate_unicode_uuid()
t_s.create_cron_trigger(
t3_name,
self.wf.name,
{},
{},
'*/2 * * * *',
None,
None,
datetime.datetime(2010, 9, 21)
)
t4_name = 'trigger-%s' % utils.generate_unicode_uuid()
t_s.create_cron_trigger(
t4_name,
self.wf.name,
{},
{},
'*/3 * * * *',
None,
None,
datetime.datetime.now() + datetime.timedelta(0, 50)
)
trigger_names = [t.name for t in t_s.get_next_cron_triggers()]
self.assertEqual([t2_name, t1_name, t3_name], trigger_names)
def test_start_workflow(self, get_engine_client_mock):
cfg.CONF.set_default('auth_enable', True, group='pecan')
wf = workflows.create_workflows(WORKFLOW_LIST)[0]
t = triggers.create_cron_trigger(
'trigger-%s' % utils.generate_unicode_uuid(), wf.name, {}, {},
'* * * * * */1', None, None, None)
self.assertEqual('my_trust_id', t.trust_id)
cfg.CONF.set_default('auth_enable', False, group='pecan')
next_trigger = triggers.get_next_cron_triggers()[0]
next_execution_time_before = next_trigger.next_execution_time
periodic.process_cron_triggers_v2(None, None)
start_wf_mock = get_engine_client_mock.return_value.start_workflow
start_wf_mock.assert_called_once()
# Check actual parameters of the call.
self.assertEqual(('my_wf', '', None, {}),
start_wf_mock.mock_calls[0][1])
self.assertIn(t.id, start_wf_mock.mock_calls[0][2]['description'])
self._await(lambda: triggers.get_next_cron_triggers(),
fail_message="No triggers were found")
next_triggers = triggers.get_next_cron_triggers()
self.assertEqual(1, len(next_triggers))
next_trigger = next_triggers[0]
next_execution_time_after = next_trigger.next_execution_time
# Checking the workflow was executed, by
# verifying that the next execution time changed.
self.assertNotEqual(next_execution_time_before,
next_execution_time_after)
def test_workflow_without_auth(self):
cfg.CONF.set_default('auth_enable', False, group='pecan')
wf = workflows.create_workflows(WORKFLOW_LIST)[0]
triggers.create_cron_trigger(
'test',
wf.name,
{},
{},
'* * * * * */1',
None,
None,
None
)
next_triggers = triggers.get_next_cron_triggers()
self.assertEqual(1, len(next_triggers))
next_trigger = next_triggers[0]
next_execution_time_before = next_trigger.next_execution_time
periodic.MistralPeriodicTasks(cfg.CONF).process_cron_triggers_v2(None)
next_triggers = triggers.get_next_cron_triggers()
self.assertEqual(1, len(next_triggers))
next_trigger = next_triggers[0]
next_execution_time_after = next_trigger.next_execution_time
self.assertNotEqual(
next_execution_time_before,
next_execution_time_after
)
def test_get_trigger_in_correct_orders(self):
t_s.create_cron_trigger(
'test1',
self.wf.name,
{},
{},
'*/5 * * * *',
None,
None,
datetime.datetime(2010, 8, 25)
)
t_s.create_cron_trigger(
'test2',
self.wf.name,
{},
{},
'*/1 * * * *',
None,
None,
datetime.datetime(2010, 8, 22)
)
t_s.create_cron_trigger(
'test3',
self.wf.name,
{},
{},
'*/2 * * * *',
None,
None,
datetime.datetime(2010, 9, 21)
)
t_s.create_cron_trigger(
'test4',
self.wf.name,
{},
{},
'*/3 * * * *',
None,
None,
datetime.datetime.now() + datetime.timedelta(0, 50)
)
trigger_names = [t.name for t in t_s.get_next_cron_triggers()]
self.assertEqual(trigger_names, ['test2', 'test1', 'test3'])
def test_get_trigger_in_correct_orders(self):
t_s.create_cron_trigger('test1', self.wf.name, {}, {}, '*/5 * * * *',
None, None, datetime.datetime(2010, 8, 25))
t_s.create_cron_trigger('test2', self.wf.name, {}, {}, '*/1 * * * *',
None, None, datetime.datetime(2010, 8, 22))
t_s.create_cron_trigger('test3', self.wf.name, {}, {}, '*/2 * * * *',
None, None, datetime.datetime(2010, 9, 21))
t_s.create_cron_trigger(
'test4', self.wf.name, {}, {}, '*/3 * * * *', None, None,
datetime.datetime.now() + datetime.timedelta(0, 50))
trigger_names = [t.name for t in t_s.get_next_cron_triggers()]
self.assertEqual(trigger_names, ['test2', 'test1', 'test3'])
def process_cron_triggers_v2(self, ctx):
LOG.debug("Processing cron triggers...")
for trigger in triggers.get_next_cron_triggers():
LOG.debug("Processing cron trigger: %s", trigger)
try:
# Setup admin context before schedule triggers.
ctx = security.create_context(trigger.trust_id,
trigger.project_id)
auth_ctx.set_ctx(ctx)
LOG.debug("Cron trigger security context: %s", ctx)
# Try to advance the cron trigger next_execution_time and
# remaining_executions if relevant.
modified = advance_cron_trigger(trigger)
# If cron trigger was not already modified by another engine.
if modified:
LOG.debug("Starting workflow '%s' by cron trigger '%s'",
trigger.workflow.name, trigger.name)
description = {
"description": ("Workflow execution created by cron"
" trigger '(%s)'." % trigger.id),
"triggered_by": {
"type": "cron_trigger",
"id": trigger.id,
"name": trigger.name,
}
}
rpc.get_engine_client().start_workflow(
trigger.workflow.name,
trigger.workflow.namespace,
trigger.workflow_input,
description=json.dumps(description),
**trigger.workflow_params)
except Exception:
# Log and continue to next cron trigger.
LOG.exception("Failed to process cron trigger %s",
str(trigger))
finally:
auth_ctx.set_ctx(None)
