def test_run_helloworld_sync_env(sync_service):
"""Successfully execute the helloworld example that contains a notebook step
in the Python environment that rund flowServ."""
# -- Setup ----------------------------------------------------------------
#
# Start a new run for the workflow template.
with sync_service() as api:
workflow_id = create_workflow(api,
source=BENCHMARK_DIR,
specfile=SPEC_FILE)
user_id = create_user(api)
with sync_service(user_id=user_id) as api:
group_id = create_group(api, workflow_id)
args = [serialize_arg('greeting', 'Hey there')]
run_id = start_run(api, group_id, arguments=args)
# -- Validate the run handle against the expected state -------------------
with sync_service(user_id=user_id) as api:
r = api.runs().get_run(run_id)
serialize.validate_run_handle(r, state=st.STATE_SUCCESS)
# The run should have the greetings.txt file as a result.
files = dict()
for obj in r['files']:
files[obj['name']] = obj['id']
assert len(files) == 2
fh = api.runs().get_result_file(run_id=run_id,
file_id=files['results/greetings.txt'])
value = fh.open().read().decode('utf-8').strip()
assert 'Hey there Alice!' in value
assert 'Hey there Bob!' in value
def test_run_helloworld_sync(sync_service, specfile, state):
"""Execute the helloworld example."""
# -- Setup ----------------------------------------------------------------
#
# Start a new run for the workflow template.
with sync_service() as api:
workflow_id = create_workflow(api,
source=TEMPLATE_DIR,
specfile=specfile)
user_id = create_user(api)
with sync_service(user_id=user_id) as api:
group_id = create_group(api, workflow_id)
names = io_file(data=['Alice', 'Bob'], format='plain/text')
file_id = upload_file(api, group_id, names)
args = [
serialize_arg('names', serialize_fh(file_id, 'data/names.txt')),
serialize_arg('sleeptime', 3)
]
run_id = start_run(api, group_id, arguments=args)
# -- Validate the run handle against the expected state -------------------
with sync_service(user_id=user_id) as api:
r = api.runs().get_run(run_id)
serialize.validate_run_handle(r, state=state)
if state == st.STATE_SUCCESS:
# The run should have the greetings.txt file as a result.
files = dict()
for obj in r['files']:
files[obj['name']] = obj['id']
assert len(files) == 1
fh = api.runs().get_result_file(
run_id=run_id, file_id=files['results/greetings.txt'])
value = fh.open().read().decode('utf-8').strip()
assert 'Hello Alice!' in value
assert 'Hello Bob!' in value
def test_cancel_remote_workflow(tmpdir):
"""Cancel the execution of a remote workflow."""
# -- Setup ----------------------------------------------------------------
#
env = Config().basedir(tmpdir)
engine = RemoteTestController(client=RemoteTestClient(runcount=100),
poll_interval=1,
is_async=True)
service = LocalAPIFactory(env=env, engine=engine)
engine.service = service
# -- Start a new run for the workflow template.
with service() as api:
workflow_id = create_workflow(api, source=TEMPLATE_DIR)
user_id = create_user(api)
with service(user_id=user_id) as api:
group_id = create_group(api, workflow_id)
run_id = start_run(api, group_id)
# -- Poll workflow state every second.
with service(user_id=user_id) as api:
run = api.runs().get_run(run_id=run_id)
while run['state'] == st.STATE_PENDING:
time.sleep(1)
with service(user_id=user_id) as api:
run = api.runs().get_run(run_id=run_id)
serialize.validate_run_handle(run, state=st.STATE_RUNNING)
with service(user_id=user_id) as api:
api.runs().cancel_run(run_id=run_id, reason='test')
# Sleep to ensure that the workflow monitor polls the state and makes an
# attempt to update the run state. This should raise an error for the
# monitor. The error is not propagated here or to the run.
time.sleep(3)
with service(user_id=user_id) as api:
run = api.runs().get_run(run_id=run_id)
serialize.validate_run_handle(run, state=st.STATE_CANCELED)
assert run['messages'][0] == 'test'
def test_run_remote_workflow_with_error(tmpdir):
"""Execute the remote workflow example that will end in an error state in
asynchronous mode.
"""
# -- Setup ----------------------------------------------------------------
#
# Start a new run for the workflow template.
env = Config().basedir(tmpdir)
engine = RemoteTestController(client=RemoteTestClient(runcount=3,
error='some error'),
poll_interval=1,
is_async=True)
service = LocalAPIFactory(env=env, engine=engine)
engine.service = service
with service() as api:
workflow_id = create_workflow(api, source=TEMPLATE_DIR)
user_id = create_user(api)
with service(user_id=user_id) as api:
group_id = create_group(api, workflow_id)
run_id = start_run(api, group_id)
# Poll workflow state every second.
with service(user_id=user_id) as api:
run = api.runs().get_run(run_id=run_id)
while run['state'] in st.ACTIVE_STATES:
time.sleep(1)
with service(user_id=user_id) as api:
run = api.runs().get_run(run_id=run_id)
serialize.validate_run_handle(run, state=st.STATE_ERROR)
assert run['messages'][0] == 'some error'
def test_run_remote_workflow_error(is_async, tmpdir):
"""Execute the remote workflow example synchronized and in asynchronous
mode when execution results in an error state.
"""
# -- Setup ----------------------------------------------------------------
env = Config().volume(FStore(basedir=str(tmpdir))).auth()
engine = RemoteWorkflowController(client=RemoteTestClient(
runcount=3, error='some error'),
poll_interval=0.1,
is_async=is_async)
service = LocalAPIFactory(env=env, engine=engine)
# Need to set the association between the engine and the service explicitly
# after the API is created.
engine.service = service
with service() as api:
workflow_id = create_workflow(api, source=BENCHMARK_DIR)
user_id = create_user(api)
with service(user_id=user_id) as api:
group_id = create_group(api, workflow_id)
# -- Unit test ------------------------------------------------------------
# Start a new run
with service(user_id=user_id) as api:
run_id = start_run(api, group_id)
# Poll workflow state every second.
with service(user_id=user_id) as api:
run = api.runs().get_run(run_id=run_id)
watch_dog = 30
while run['state'] in st.ACTIVE_STATES and watch_dog:
time.sleep(1)
watch_dog -= 1
with service(user_id=user_id) as api:
run = api.runs().get_run(run_id=run_id)
serialize.validate_run_handle(run, state=st.STATE_ERROR)
assert run['messages'] == ['some error']
def test_create_run_local(local_service, hello_world):
"""Test life cycle for successful run using the local service."""
# -- Setup ----------------------------------------------------------------
#
# Start a new run for a group of the 'Hello World' workflow and set it into
# success state.
tmpdir = tempfile.mkdtemp()
with local_service() as api:
user_1 = create_user(api)
user_2 = create_user(api)
workflow_id = hello_world(api).workflow_id
with local_service(user_id=user_1) as api:
group_id = create_group(api, workflow_id=workflow_id, users=[user_1])
run_id, file_id = start_hello_world(api, group_id)
result = {'group': group_id, 'run': run_id}
write_results(rundir=tmpdir,
files=[(result, None, 'results/data.json'),
([group_id, run_id], 'txt/plain', 'values.txt')])
api.runs().update_run(run_id=run_id,
state=api.runs().backend.success(
run_id,
files=['results/data.json', 'values.txt']),
rundir=tmpdir)
assert not os.path.exists(tmpdir)
# -- Validate run handle --------------------------------------------------
with local_service(user_id=user_1) as api:
r = api.runs().get_run(run_id=run_id)
serialize.validate_run_handle(r, st.STATE_SUCCESS)
assert is_fh(r['arguments'][0]['value'])
# -- Error when non-member attempts to access run -------------------------
with local_service(user_id=user_2) as api:
with pytest.raises(err.UnauthorizedAccessError):
api.runs().get_run(run_id=run_id)
def test_create_run_local(local_service, hello_world):
"""Test life cycle for successful run using the local service."""
# -- Setup ----------------------------------------------------------------
#
# Start a new run for a group of the 'Hello World' workflow and set it into
# success state.
fs = FileSystemStorage(basedir=tempfile.mkdtemp())
with local_service() as api:
user_1 = create_user(api)
user_2 = create_user(api)
workflow_id = hello_world(api).workflow_id
with local_service(user_id=user_1) as api:
group_id = create_group(api, workflow_id=workflow_id, users=[user_1])
run_id, file_id = start_hello_world(api, group_id)
result = {'group': group_id, 'run': run_id}
write_results(runstore=fs,
files=[(result, None, 'results/data.json'),
({
'avg_count': 3.5,
'max_len': 30
}, None, 'results/analytics.json'),
([group_id, run_id], 'txt/plain', 'values.txt')])
api.runs().update_run(run_id=run_id,
state=api.runs().backend.success(
run_id,
files=['results/data.json', 'values.txt']),
runstore=fs)
# -- Validate run handle --------------------------------------------------
with local_service(user_id=user_1) as api:
r = api.runs().get_run(run_id=run_id)
serialize.validate_run_handle(r, st.STATE_SUCCESS)
assert is_fh(r['arguments'][0]['value'])
# -- Error when non-member attempts to access run -------------------------
with local_service(user_id=user_2) as api:
with pytest.raises(err.UnauthorizedAccessError):
api.runs().get_run(run_id=run_id)
# -- Error for run with invalid arguments ---------------------------------
with local_service(user_id=user_1) as api:
with pytest.raises(err.DuplicateArgumentError):
api.runs().start_run(group_id=group_id,
arguments=[{
'name': 'sleeptime',
'value': 1
}, {
'name': 'sleeptime',
'value': 2
}])['id']
def test_cancel_remote_workflow(tmpdir):
"""Cancel the execution of a remote workflow."""
# -- Setup ----------------------------------------------------------------
env = Config().volume(FStore(basedir=str(tmpdir))).auth()
engine = RemoteWorkflowController(client=RemoteTestClient(runcount=100),
poll_interval=0.25,
is_async=True)
service = LocalAPIFactory(env=env, engine=engine)
# Need to set the association between the engine and the service explicitly
# after the API is created.
engine.service = service
with service() as api:
workflow_id = create_workflow(api, source=BENCHMARK_DIR)
user_id = create_user(api)
with service(user_id=user_id) as api:
group_id = create_group(api, workflow_id)
# -- Unit test ------------------------------------------------------------
# Start a new run
with service(user_id=user_id) as api:
run_id = start_run(api, group_id)
# -- Poll workflow state every second.
with service(user_id=user_id) as api:
run = api.runs().get_run(run_id=run_id)
watch_dog = 30
while run['state'] == st.STATE_PENDING and watch_dog:
time.sleep(0.1)
watch_dog -= 1
with service(user_id=user_id) as api:
run = api.runs().get_run(run_id=run_id)
serialize.validate_run_handle(run, state=st.STATE_RUNNING)
with service(user_id=user_id) as api:
api.runs().cancel_run(run_id=run_id, reason='test')
# Sleep to ensure that the workflow monitor polls the state and makes an
# attempt to update the run state. This should raise an error for the
# monitor. The error is not propagated here or to the run.
time.sleep(1)
with service(user_id=user_id) as api:
run = api.runs().get_run(run_id=run_id)
serialize.validate_run_handle(run, state=st.STATE_CANCELED)
assert run['messages'][0] == 'test'
def test_run_remote_workflow(tmpdir, is_async):
"""Execute the remote workflow example synchronized and in asynchronous
mode.
"""
# -- Setup ----------------------------------------------------------------
#
env = Config().basedir(tmpdir)
engine = RemoteTestController(client=RemoteTestClient(runcount=3,
data=['success']),
poll_interval=1,
is_async=is_async)
service = LocalAPIFactory(env=env, engine=engine)
engine.service = service
# Start a new run for the workflow template.
with service() as api:
workflow_id = create_workflow(api, source=TEMPLATE_DIR)
user_id = create_user(api)
with service(user_id=user_id) as api:
group_id = create_group(api, workflow_id)
run_id = start_run(api, group_id)
# Poll workflow state every second.
with service(user_id=user_id) as api:
run = api.runs().get_run(run_id=run_id)
watch_dog = 30
while run['state'] in st.ACTIVE_STATES and watch_dog:
time.sleep(1)
watch_dog -= 1
with service(user_id=user_id) as api:
run = api.runs().get_run(run_id=run_id)
serialize.validate_run_handle(run, state=st.STATE_SUCCESS)
files = dict()
for obj in run['files']:
files[obj['name']] = obj['id']
f_id = files['results/data.txt']
with service(user_id=user_id) as api:
fh = api.runs().get_result_file(run_id=run_id, file_id=f_id)
data = fh.open().read().decode('utf-8')
assert 'success' in data