/// <inheritdoc />
public object Invoke(IVariableProvider variables, params object[] arguments)
{
if (!(variables.GetProvider("log")?["log"] is WorkableLogger logger))
{
throw new WorkflowException($"Calling a workflow as method requires an existing logger of type '{nameof(WorkableLogger)}' accessible under variable 'log'");
}
if (!(arguments.FirstOrDefault() is IDictionary scriptarguments))
{
throw new InvalidOperationException($"Parameters for a workflow call need to be a dictionary ('{arguments.FirstOrDefault()?.GetType()}')");
}
if (!(scriptarguments is IDictionary <string, object> parameters))
{
parameters = new Dictionary <string, object>();
foreach (object key in scriptarguments.Keys)
{
parameters[key.ToString() ?? string.Empty] = scriptarguments[key];
}
}
return(Task.Run(async() => {
WorkflowDetails workflow = await LoadWorkflow();
WorkflowInstance instance = await compiler.BuildWorkflow(workflow);
return await executor.Execute(instance, logger, parameters, false, CancellationToken.None);
}).GetAwaiter().GetResult());
}
async Task <WorkflowInstance> GetWorkflowInstance(string name)
{
WorkflowDetails workflow = await workflowservice.GetWorkflow(name);
WorkflowInstance instance = await workflowcompiler.BuildWorkflow(workflow);
return(instance);
}
/// <inheritdoc />
public object Execute(IDictionary <string, object> arguments)
{
return(Task.Run(async() => {
WorkflowDetails workflow = await workflowservice.GetWorkflow(name, revision);
WorkflowInstance instance = await compiler.BuildWorkflow(workflow);
return await executor.Execute(instance, logger, arguments, false, CancellationToken.None);
}).GetAwaiter().GetResult());
}
public async Task <WorkableTask> Execute([FromBody] ExecuteWorkflowParameters parameters)
{
logger.LogInformation("Executing {workflow} with parameters '{parameters}'",
parameters.Id?.ToString() ?? parameters.Name,
string.Join(";", parameters.Parameters?.Select(p => $"{p.Key}={p.Value}") ?? new string[0]));
try {
if (parameters.Id.HasValue)
{
if (!string.IsNullOrEmpty(parameters.Name))
{
throw new ArgumentException("Either id or name has to be set, not both");
}
return(await executionservice.Execute(await compiler.BuildWorkflow(parameters.Id.Value, parameters.Revision), parameters.Parameters, parameters.Profile ?? false, parameters.Wait));
}
if (!string.IsNullOrEmpty(parameters.Name))
{
return(await executionservice.Execute(await compiler.BuildWorkflow(parameters.Name, parameters.Revision), parameters.Parameters, parameters.Profile ?? false, parameters.Wait));
}
if (parameters.Workflow != null)
{
return(await executionservice.Execute(await compiler.BuildWorkflow(parameters.Workflow), parameters.Parameters, parameters.Profile ?? false, parameters.Wait));
}
}
catch (Exception e) {
WorkableTask failtask = new WorkableTask {
Id = Guid.NewGuid(),
Status = TaskStatus.Failure,
Started = DateTime.Now,
Finished = DateTime.Now,
Log = new List <string>(new[] {
e.ToString()
}),
Parameters = parameters.Parameters,
Type = WorkableType.Workflow,
};
await taskservice.StoreTask(failtask);
return(failtask);
}
throw new ArgumentException("Workflow id or name is required");
}
async Task CheckTasks()
{
List <ScheduledTask> tasks = new List <ScheduledTask>();
ScheduledTaskFilter filter = new ScheduledTaskFilter {
DueTime = DateTime.Now
};
while (true)
{
Page <ScheduledTask> page = await scheduledtaskservice.List(filter);
tasks.AddRange(page.Result);
if (page.Result.Length == 0 || !page.Continue.HasValue)
{
break;
}
filter.Continue = page.Continue;
}
foreach (ScheduledTask task in tasks)
{
switch (task.WorkableType)
{
case WorkableType.Workflow:
await workflowexecutor.Execute(await workflowcompiler.BuildWorkflow(task.WorkableName), new Dictionary <string, object>(), false);
break;
case WorkableType.Script:
await scriptexecutor.Execute(task.WorkableName, task.WorkableRevision);
break;
}
try {
await scheduledtaskservice.UpdateExecution(task.Id, task.NextExecutionTime());
}
catch (Exception e) {
logger.LogError(e, $"Unable to reschedule task '{task.Id}'");
}
}
}