public async Task <bool> SuspendWorkflow(string workflowId)
{
if (!await _lockProvider.AcquireLock(workflowId, new CancellationToken()))
{
return(false);
}
try
{
var wf = await _persistenceStore.GetWorkflowInstance(workflowId);
if (wf.Status == WorkflowStatus.Runnable)
{
wf.Status = WorkflowStatus.Suspended;
await _persistenceStore.PersistWorkflow(wf);
return(true);
}
return(false);
}
finally
{
await _lockProvider.ReleaseLock(workflowId);
}
}
public async Task <bool> SuspendWorkflow(string workflowId)
{
if (!await _lockProvider.AcquireLock(workflowId, new CancellationToken()))
{
return(false);
}
try
{
var wf = await _persistenceStore.GetWorkflowInstance(workflowId);
if (wf.Status == WorkflowStatus.Runnable)
{
wf.Status = WorkflowStatus.Suspended;
await _persistenceStore.PersistWorkflow(wf);
await _eventHub.PublishNotification(new WorkflowSuspended()
{
EventTimeUtc = DateTime.UtcNow,
Reference = wf.Reference,
WorkflowInstanceId = wf.Id,
WorkflowDefinitionId = wf.WorkflowDefinitionId,
Version = wf.Version
});
return(true);
}
return(false);
}
finally
{
await _lockProvider.ReleaseLock(workflowId);
}
}
public async Task <ActionResult <WorkflowInstance> > Get(string id)
{
var result = await _persistenceProvider.GetWorkflowInstance(id);
if (result == null)
{
return(NotFound());
}
return(Ok(_mapper.Map <WorkflowInstance>(result)));
}
//[Authorize(Policy = Policies.Viewer)]
public async Task <ActionResult <WorkflowInstance> > Get(string id)
{
var logTrace = new LogTrace();
AiLogger.LogInfo(logTrace, "Workflow Get: " + id);
var result = await _persistenceProvider.GetWorkflowInstance(id);
if (result == null)
{
return(NotFound());
}
return(Ok(_mapper.Map <WorkflowInstance>(result)));
}
private async Task <bool> SeedSubscription(Event evt, EventSubscription sub, List <string> toQueue, CancellationToken cancellationToken)
{
foreach (var eventId in await _persistenceStore.GetEvents(sub.EventName, sub.EventKey, sub.SubscribeAsOf))
{
if (eventId == evt.Id)
{
continue;
}
var siblingEvent = await _persistenceStore.GetEvent(eventId);
if ((!siblingEvent.IsProcessed) && (siblingEvent.EventTime < evt.EventTime))
{
await QueueProvider.QueueWork(eventId, QueueType.Event);
return(false);
}
if (!siblingEvent.IsProcessed)
{
toQueue.Add(siblingEvent.Id);
}
}
if (!await _lockProvider.AcquireLock(sub.WorkflowId, cancellationToken))
{
Logger.LogInformation("Workflow locked {0}", sub.WorkflowId);
return(false);
}
try
{
var workflow = await _persistenceStore.GetWorkflowInstance(sub.WorkflowId);
var pointers = workflow.ExecutionPointers.Where(p => p.EventName == sub.EventName && p.EventKey == sub.EventKey && !p.EventPublished && p.EndTime == null);
foreach (var p in pointers)
{
p.EventData = evt.EventData;
p.EventPublished = true;
p.Active = true;
}
workflow.NextExecution = 0;
await _persistenceStore.PersistWorkflow(workflow);
await _persistenceStore.TerminateSubscription(sub.Id);
return(true);
}
catch (Exception ex)
{
Logger.LogError(ex, ex.Message);
return(false);
}
finally
{
await _lockProvider.ReleaseLock(sub.WorkflowId);
await QueueProvider.QueueWork(sub.WorkflowId, QueueType.Workflow);
}
}
public async Task <IActionResult> Get(string id)
{
var result = await _workflowStore.GetWorkflowInstance(id);
_logger.LogInformation("Workflow Instance: {result}", result);
return(Ok("Workflow Instance: {result}" + result));
}
/// <summary>
/// Worker thread body
/// </summary>
private void RunWorkflows()
{
IWorkflowExecutor workflowExecutor = _serviceProvider.GetService <IWorkflowExecutor>();
IPersistenceProvider persistenceStore = _serviceProvider.GetService <IPersistenceProvider>();
while (!_shutdown)
{
try
{
var workflowId = QueueProvider.DequeueForProcessing().Result;
if (workflowId != null)
{
try
{
if (LockProvider.AcquireLock(workflowId).Result)
{
WorkflowInstance workflow = null;
try
{
workflow = persistenceStore.GetWorkflowInstance(workflowId).Result;
if (workflow.Status == WorkflowStatus.Runnable)
{
workflowExecutor.Execute(workflow, persistenceStore, Options);
}
}
finally
{
LockProvider.ReleaseLock(workflowId).Wait();
if (workflow != null)
{
if ((workflow.Status == WorkflowStatus.Runnable) && workflow.NextExecution.HasValue && workflow.NextExecution.Value < DateTime.Now.ToUniversalTime().Ticks)
{
QueueProvider.QueueForProcessing(workflowId);
}
}
}
}
else
{
Logger.LogInformation("Workflow locked {0}", workflowId);
}
}
catch (Exception ex)
{
Logger.LogError(ex.Message);
}
}
else
{
Thread.Sleep(Options.IdleTime); //no work
}
}
catch (Exception ex)
{
Logger.LogError(ex.Message);
}
}
}
//[Authorize(Policy = Policies.Controller)]
public async Task <ActionResult <WorkflowInstance> > StartWorkflow(string id)
{
string contentReq = null;
using (StreamReader reader = new StreamReader(Request.Body, Encoding.UTF8))
{
contentReq = await reader.ReadToEndAsync();
}
var logTrace = new LogTrace();
AiLogger.LogInfo(logTrace, "Workflow Start: " + contentReq);
object workflowData = contentReq;
string workflowId = null;
if (id.Equals(CompressJobWorkflow.WorkflowId))
{
workflowId = CompressJobWorkflow.WorkflowId;
workflowData = NewtonJsonConvert.DeserializeObject <CompressJobData>(contentReq);
}
else if (id.Equals(WfFileInWorkflow.WorkflowId))
{
workflowId = WfFileInWorkflow.WorkflowId;
workflowData = NewtonJsonConvert.DeserializeObject <WfFileInData>(contentReq);
}
else if (id.Equals(Test01UserWorkflow.WorkflowId))
{
var wfEvent = Newtonsoft.Json.JsonConvert.DeserializeObject <Pdf4meWorkflowEvent>(contentReq);
workflowData = new Pdf4meWorkflowData()
{
WorkflowEvent = wfEvent
};
workflowId = Test01UserWorkflow.WorkflowId;
//workflowData = NewtonJsonConvert.DeserializeObject<WfFileInData>(contentReq);
}
else
{
var wfEvent = Newtonsoft.Json.JsonConvert.DeserializeObject <Pdf4meWorkflowEvent>(contentReq);
workflowData = new Pdf4meWorkflowData()
{
WorkflowEvent = wfEvent
};
workflowId = id;
}
var instanceId = await _workflowController.StartWorkflow(workflowId, workflowData);
var result = await _persistenceProvider.GetWorkflowInstance(instanceId);
return(Created(instanceId, _mapper.Map <WorkflowInstance>(result)));
}
protected override async Task ProcessItem(string itemId, CancellationToken cancellationToken)
{
if (!await _lockProvider.AcquireLock(itemId, cancellationToken))
{
Logger.LogInformation("Workflow locked {0}", itemId);
return;
}
WorkflowInstance workflow = null;
WorkflowExecutorResult result = null;
try
{
cancellationToken.ThrowIfCancellationRequested();
workflow = await _persistenceStore.GetWorkflowInstance(itemId, cancellationToken);
if (workflow.Status == WorkflowStatus.Runnable)
{
try
{
result = await _executor.Execute(workflow, cancellationToken);
}
finally
{
await _persistenceStore.PersistWorkflow(workflow, cancellationToken);
await QueueProvider.QueueWork(itemId, QueueType.Index);
_greylist.Remove($"wf:{itemId}");
}
}
}
finally
{
await _lockProvider.ReleaseLock(itemId);
if ((workflow != null) && (result != null))
{
foreach (var sub in result.Subscriptions)
{
await SubscribeEvent(sub, _persistenceStore, cancellationToken);
}
await _persistenceStore.PersistErrors(result.Errors, cancellationToken);
var readAheadTicks = _datetimeProvider.UtcNow.Add(Options.PollInterval).Ticks;
if ((workflow.Status == WorkflowStatus.Runnable) && workflow.NextExecution.HasValue && workflow.NextExecution.Value < readAheadTicks)
{
new Task(() => FutureQueue(workflow, cancellationToken)).Start();
}
}
}
}
public async void AddWorkflowData(string workflowId, string key, object data)
{
var wf = await _persistenceStore.GetWorkflowInstance(workflowId);
var dict = (wf.Data as IDictionary <string, object>);
if (dict == null)
{
throw new NullReferenceException("unable to load workflow data as dictionary");
}
if (dict.ContainsKey(key))
{
dict[key] = data;
}
else
{
dict.Add(key, data);
}
await _persistenceStore.PersistWorkflow(wf);
}
private async Task <bool> SeedSubscription(Event evt, EventSubscription sub, CancellationToken cancellationToken)
{
if (await _lockProvider.AcquireLock(sub.WorkflowId, cancellationToken))
{
try
{
var workflow = await _persistenceStore.GetWorkflowInstance(sub.WorkflowId);
var pointers = workflow.ExecutionPointers.Where(p => p.EventName == sub.EventName && p.EventKey == sub.EventKey && !p.EventPublished && p.EndTime == null);
foreach (var p in pointers)
{
p.EventData = evt.EventData;
p.EventPublished = true;
p.Active = true;
}
workflow.NextExecution = 0;
await _persistenceStore.PersistWorkflow(workflow);
await _persistenceStore.TerminateSubscription(sub.Id);
return(true);
}
catch (Exception ex)
{
Logger.LogError(ex.Message, ex);
return(false);
}
finally
{
await _lockProvider.ReleaseLock(sub.WorkflowId);
await QueueProvider.QueueWork(sub.WorkflowId, QueueType.Workflow);
}
}
else
{
Logger.LogInformation("Workflow locked {0}", sub.WorkflowId);
return(false);
}
}
private void RunPublications()
{
IPersistenceProvider persistenceStore = _serviceProvider.GetService <IPersistenceProvider>();
while (!_shutdown)
{
try
{
var pub = QueueProvider.DequeueForPublishing().Result;
if (pub != null)
{
try
{
if (LockProvider.AcquireLock(pub.WorkflowId).Result)
{
try
{
var workflow = persistenceStore.GetWorkflowInstance(pub.WorkflowId).Result;
var pointers = workflow.ExecutionPointers.Where(p => p.EventName == pub.EventName && p.EventKey == p.EventKey && !p.EventPublished);
foreach (var p in pointers)
{
p.EventData = pub.EventData;
p.EventPublished = true;
p.Active = true;
}
workflow.NextExecution = 0;
persistenceStore.PersistWorkflow(workflow);
}
catch (Exception ex)
{
Logger.LogError(ex.Message);
persistenceStore.CreateUnpublishedEvent(pub); //retry later
}
finally
{
LockProvider.ReleaseLock(pub.WorkflowId).Wait();
QueueProvider.QueueForProcessing(pub.WorkflowId);
}
}
else
{
Logger.LogInformation("Workflow locked {0}", pub.WorkflowId);
persistenceStore.CreateUnpublishedEvent(pub); //retry later
}
}
catch (Exception ex)
{
Logger.LogError(ex.Message);
}
}
else
{
Thread.Sleep(Options.IdleTime); //no work
}
}
catch (Exception ex)
{
Logger.LogError(ex.Message);
}
}
}
protected WorkflowStatus GetStatus(string workflowId)
{
var instance = PersistenceProvider.GetWorkflowInstance(workflowId).Result;
return(instance.Status);
}
public async Task <IActionResult> Get(string id)
{
var result = await _workflowStore.GetWorkflowInstance(id);
return(Json(result));
}
/// <summary>
/// Worker thread body
/// </summary>
private async void RunWorkflows()
{
while (!_shutdown)
{
try
{
var workflowId = await _queueProvider.DequeueWork(QueueType.Workflow);
if (workflowId != null)
{
try
{
if (await _lockProvider.AcquireLock(workflowId))
{
WorkflowInstance workflow = null;
WorkflowExecutorResult result = null;
try
{
workflow = await _persistenceStore.GetWorkflowInstance(workflowId);
if (workflow.Status == WorkflowStatus.Runnable)
{
try
{
result = _executor.Execute(workflow, _options);
}
finally
{
await _persistenceStore.PersistWorkflow(workflow);
}
}
}
finally
{
await _lockProvider.ReleaseLock(workflowId);
if ((workflow != null) && (result != null))
{
foreach (var sub in result.Subscriptions)
{
await SubscribeEvent(sub);
}
await _persistenceStore.PersistErrors(result.Errors);
if ((workflow.Status == WorkflowStatus.Runnable) && workflow.NextExecution.HasValue && workflow.NextExecution.Value < DateTime.Now.ToUniversalTime().Ticks)
{
await _queueProvider.QueueWork(workflowId, QueueType.Workflow);
}
}
}
}
else
{
_logger.LogInformation("Workflow locked {0}", workflowId);
}
}
catch (Exception ex)
{
_logger.LogError(ex.Message);
}
}
else
{
await Task.Delay(_options.IdleTime); //no work
}
}
catch (Exception ex)
{
_logger.LogError(ex.Message);
}
}
}
public async Task <TDataWorkflow> GetFlowInstance <TDataWorkflow>(string instanceId) where TDataWorkflow : class, IDataWorkflow, new()
{
return(await _workflowStore.GetWorkflowInstance(instanceId) as TDataWorkflow);
}