def legacy_workflow_stepper():
"""
Function to tick the legacy workflows
"""
from datetime import timedelta
from aiida.daemon.timestamps import set_timestamp_workflow_stepper, get_timestamp_workflow_stepper
from aiida.daemon.workflowmanager import execute_steps
logger.debug('Checking for workflows to manage')
# RUDIMENTARY way to check if this task is already running (to avoid acting
# again and again on the same workflow steps)
try:
stepper_is_running = (
get_timestamp_workflow_stepper(when='stop') -
get_timestamp_workflow_stepper(when='start')) <= timedelta(0)
except TypeError:
# When some timestamps are None (undefined)
stepper_is_running = (
get_timestamp_workflow_stepper(when='stop') is None
and get_timestamp_workflow_stepper(when='start') is not None)
if not stepper_is_running:
# The previous wf manager stopped already -> we can run a new one
set_timestamp_workflow_stepper(when='start')
logger.debug('Running execute_steps')
execute_steps()
set_timestamp_workflow_stepper(when='stop')
else:
logger.debug('Execute_steps already running')
def test_failing_calc_in_wf(self):
"""
This test checks that a workflow (but also a workflow with
sub-workflows) that has an exception at one of its steps stops
properly and it is not left as RUNNING.
"""
from aiida.daemon.workflowmanager import execute_steps
from aiida.workflows.test import (FailingWFTestSimple,
FailingWFTestSimpleWithSubWF)
try:
# Testing the error propagation of a simple workflow
wf = FailingWFTestSimple()
wf.store()
step_no = 0
wf.start()
while wf.is_running():
execute_steps()
step_no += 1
self.assertLess(step_no, 5, "This workflow should have stopped "
"since it is failing")
# Testing the error propagation of a workflow with subworkflows
wf = FailingWFTestSimpleWithSubWF()
wf.store()
step_no = 0
wf.start()
while wf.is_running():
execute_steps()
step_no += 1
self.assertLess(step_no, 5, "This workflow should have stopped "
"since it is failing")
finally:
pass
def manual_tick_all():
from aiida.daemon.execmanager import submit_jobs, update_jobs, retrieve_jobs
from aiida.work.daemon import tick_workflow_engine
from aiida.daemon.workflowmanager import execute_steps
submit_jobs()
update_jobs()
retrieve_jobs()
execute_steps() # legacy workflows
tick_workflow_engine()
def test_failing_calc_in_wf(self):
"""
This test checks that a workflow (but also a workflow with
sub-workflows) that has an exception at one of its steps stops
properly and it is not left as RUNNING.
"""
import logging
from aiida.daemon.workflowmanager import execute_steps
from aiida.workflows.test import (FailingWFTestSimple,
FailingWFTestSimpleWithSubWF)
try:
# First of all, I re-enable logging in case it was disabled by
# mistake by a previous test (e.g. one that disables and reenables
# again, but that failed)
logging.disable(logging.NOTSET)
# Temporarily disable logging to the stream handler (i.e. screen)
# because otherwise fix_calc_states will print warnings
handler = next((h for h in logging.getLogger('aiida').handlers
if isinstance(h, logging.StreamHandler)), None)
if handler:
original_level = handler.level
handler.setLevel(logging.ERROR)
# Testing the error propagation of a simple workflow
wf = FailingWFTestSimple()
wf.store()
step_no = 0
wf.start()
while wf.is_running():
execute_steps()
step_no += 1
self.assertLess(
step_no, 5, "This workflow should have stopped "
"since it is failing")
# Testing the error propagation of a workflow with subworkflows
wf = FailingWFTestSimpleWithSubWF()
wf.store()
step_no = 0
wf.start()
while wf.is_running():
execute_steps()
step_no += 1
self.assertLess(
step_no, 5, "This workflow should have stopped "
"since it is failing")
finally:
if handler:
handler.setLevel(original_level)
def test_old_wf_results(self):
wf = WorkflowDemo()
wf.start()
while wf.is_running():
execute_steps()
class _TestWf(WorkChain):
@classmethod
def define(cls, spec):
super(_TestWf, cls).define(spec)
spec.outline(cls.start, cls.check)
def start(self):
return ToContext(res=Outputs(legacy_workflow(wf.pk)))
def check(self):
assert set(self.ctx.res) == set(wf.get_results())
_TestWf.new_instance().run_until_complete()
def test_call_old_wf(self):
wf = WorkflowDemo()
wf.start()
while wf.is_running():
execute_steps()
class _TestWf(WorkChain):
@classmethod
def define(cls, spec):
super(_TestWf, cls).define(spec)
spec.outline(cls.start, cls.check)
def start(self):
return ToContext(wf=legacy_workflow(wf.pk))
def check(self):
assert self.ctx.wf is not None
_TestWf.new_instance().run_until_complete()
def test_call_old_wf(self):
wf = WorkflowDemo()
wf.start()
while wf.is_running():
execute_steps()
class _TestWf(WorkChain):
@classmethod
def define(cls, spec):
super(_TestWf, cls).define(spec)
spec.outline(cls.begin, cls.check)
def begin(self):
return ToContext(wf=wf)
def check(self):
assert self.ctx.wf is not None
run_and_check_success(_TestWf)
def test_old_wf_results(self):
wf = WorkflowDemo()
wf.start()
while wf.is_running():
execute_steps()
test_case = self
class _TestWf(WorkChain):
@classmethod
def define(cls, spec):
super(_TestWf, cls).define(spec)
spec.outline(cls.begin, cls.check)
def begin(self):
return ToContext(res=wf)
def check(self):
test_case.assertEquals(self.ctx.res.pk, wf.pk)
run_and_check_success(_TestWf)
def test_call_on_wf_finish(self):
loop = self.runner.loop
future = plumpy.Future()
# Need to start() so it's stored
wf = WorkflowDemo()
wf.start()
def wf_done(pk):
self.assertEqual(pk, wf.pk)
loop.stop()
future.set_result(True)
self.runner.call_on_legacy_workflow_finish(wf.pk, wf_done)
# Run the wf
while wf.is_running():
execute_steps()
self._run_loop_for(10.)
self.assertTrue(future.result())
def workflow_stepper(): # daemon for legacy workflow
from aiida.daemon.workflowmanager import execute_steps
print "aiida.daemon.tasks.workflowmanager: Checking for workflows to manage"
# RUDIMENTARY way to check if this task is already running (to avoid acting
# again and again on the same workflow steps)
try:
stepper_is_running = (get_last_daemon_timestamp('workflow',when='stop')
-get_last_daemon_timestamp('workflow',when='start'))<=timedelta(0)
except TypeError:
# when some timestamps are None (undefined)
stepper_is_running = (get_last_daemon_timestamp('workflow',when='stop')
is None and get_last_daemon_timestamp('workflow',when='start') is not None)
if not stepper_is_running:
set_daemon_timestamp(task_name='workflow', when='start')
# the previous wf manager stopped already -> we can run a new one
print "aiida.daemon.tasks.workflowmanager: running execute_steps"
execute_steps()
set_daemon_timestamp(task_name='workflow', when='stop')
else:
print "aiida.daemon.tasks.workflowmanager: execute_steps already running"
def workflow_stepper(): # daemon for legacy workflow
configure_logging(daemon=True, daemon_log_file=DAEMON_LOG_FILE)
from aiida.daemon.workflowmanager import execute_steps
LOGGER.info('Checking for workflows to manage')
# RUDIMENTARY way to check if this task is already running (to avoid acting
# again and again on the same workflow steps)
try:
stepper_is_running = (get_last_daemon_timestamp(
'workflow', when='stop') - get_last_daemon_timestamp(
'workflow', when='start')) <= timedelta(0)
except TypeError:
# when some timestamps are None (undefined)
stepper_is_running = (
get_last_daemon_timestamp('workflow', when='stop') is None and
get_last_daemon_timestamp('workflow', when='start') is not None)
if not stepper_is_running:
set_daemon_timestamp(task_name='workflow', when='start')
# the previous wf manager stopped already -> we can run a new one
LOGGER.info('running execute_steps')
execute_steps()
set_daemon_timestamp(task_name='workflow', when='stop')
else:
LOGGER.info('execute_steps already running')
def workflow_stepper(): # daemon for legacy workflow
from aiida.daemon.workflowmanager import execute_steps
print "aiida.daemon.tasks.workflowmanager: Checking for workflows to manage"
set_daemon_timestamp(task_name='workflow', when='start')
execute_steps()
set_daemon_timestamp(task_name='workflow', when='stop')
