def _get_action_input(wf_spec, task_ex, task_spec, ctx):
input_dict = expr.evaluate_recursively(task_spec.get_input(), ctx)
action_spec_name = task_spec.get_action_name()
action_def = e_utils.resolve_action_definition(task_ex.workflow_name,
wf_spec.get_name(),
action_spec_name)
input_dict = utils.merge_dicts(input_dict,
_get_action_defaults(task_ex, task_spec),
overwrite=False)
if action_def.spec:
# Ad-hoc action.
action_spec = spec_parser.get_action_spec(action_def.spec)
base_name = action_spec.get_base()
action_def = e_utils.resolve_action_definition(task_ex.workflow_name,
wf_spec.get_name(),
base_name)
e_utils.validate_input(action_def, action_spec, input_dict)
base_input = action_spec.get_base_input()
if base_input:
input_dict = expr.evaluate_recursively(base_input, input_dict)
else:
input_dict = {}
return input_dict
def _schedule_run_action(task_ex, task_spec, action_input, index):
wf_ex = task_ex.workflow_execution
wf_spec = spec_parser.get_workflow_spec(wf_ex.spec)
action_spec_name = task_spec.get_action_name()
# TODO(rakhmerov): Refactor ad-hoc actions and isolate them.
action_def = e_utils.resolve_action_definition(wf_ex.workflow_name,
wf_spec.get_name(),
action_spec_name)
if action_def.spec:
# Ad-hoc action.
action_spec = spec_parser.get_action_spec(action_def.spec)
base_name = action_spec.get_base()
action_def = e_utils.resolve_action_definition(task_ex.workflow_name,
wf_spec.get_name(),
base_name)
action_ex = _create_action_execution(task_ex, action_def, action_input,
index)
target = expr.evaluate_recursively(
task_spec.get_target(),
utils.merge_dicts(copy.deepcopy(action_input),
copy.copy(task_ex.in_context)))
scheduler.schedule_call(None,
'mistral.engine.task_handler.run_action',
0,
action_ex_id=action_ex.id,
target=target)
def _get_with_items_input(wf_spec, task_ex, task_spec, ctx):
"""Calculate input array for separating each action input.
Example:
DSL:
with_items:
- itemX in <% $.arrayI %>
- itemY in <% $.arrayJ %>
Assume arrayI = [1, 2], arrayJ = ['a', 'b'].
with_items_input = {
"itemX": [1, 2],
"itemY": ['a', 'b']
}
Then we get separated input:
inputs_per_item = [
{'itemX': 1, 'itemY': 'a'},
{'itemX': 2, 'itemY': 'b'}
]
:return: list containing dicts of each action input.
"""
with_items_inputs = expr.evaluate_recursively(task_spec.get_with_items(),
ctx)
with_items.validate_input(with_items_inputs)
inputs_per_item = []
for key, value in with_items_inputs.items():
for index, item in enumerate(value):
iter_context = {key: item}
if index >= len(inputs_per_item):
inputs_per_item.append(iter_context)
else:
inputs_per_item[index].update(iter_context)
action_inputs = []
for item_input in inputs_per_item:
new_ctx = utils.merge_dicts(item_input, ctx)
action_inputs.append(
_get_workflow_or_action_input(wf_spec, task_ex, task_spec,
new_ctx))
return action_inputs
def transform_action_result(wf_name, wf_spec_name, action_spec_name, result):
action_def = resolve_action_definition(wf_name, wf_spec_name,
action_spec_name)
if not action_def.spec:
return result
transformer = spec_parser.get_action_spec(action_def.spec).get_output()
if transformer is None:
return result
return wf_utils.Result(data=expr.evaluate_recursively(
transformer, result.data),
error=result.error)
def _schedule_noop_action(task_ex, task_spec):
wf_ex = task_ex.workflow_execution
wf_spec = spec_parser.get_workflow_spec(wf_ex.spec)
action_def = e_utils.resolve_action_definition(wf_ex.workflow_name,
wf_spec.get_name(),
'std.noop')
action_ex = _create_action_execution(task_ex, action_def, {})
target = expr.evaluate_recursively(task_spec.get_target(),
task_ex.in_context)
scheduler.schedule_call(None,
'mistral.engine.task_handler.run_action',
0,
action_ex_id=action_ex.id,
target=target)
def transform_action_result(wf_name, wf_spec_name, action_spec_name, result):
action_def = resolve_action_definition(
wf_name,
wf_spec_name,
action_spec_name
)
if not action_def.spec:
return result
transformer = spec_parser.get_action_spec(action_def.spec).get_output()
if transformer is None:
return result
return wf_utils.Result(
data=expr.evaluate_recursively(transformer, result.data),
error=result.error
)
def _get_workflow_input(task_spec, ctx):
return expr.evaluate_recursively(task_spec.get_input(), ctx)