Misc improvements (#269)

Author: danielgerlag

src/WorkflowCore/Interface/IQueueProvider.cs

@@ -32,5 +32,5 @@ public interface IQueueProvider : IDisposable
         Task Stop();
     }
 
-    public enum QueueType { Workflow = 0, Event = 1 }
+    public enum QueueType { Workflow = 0, Event = 1, Index = 2 }
 }

src/WorkflowCore/Interface/IStepBuilder.cs

@@ -21,6 +21,13 @@ public interface IStepBuilder<TData, TStepBody>
         /// <returns></returns>
         IStepBuilder<TData, TStepBody> Name(string name);
 
+        /// <summary>
+        /// Specifies a custom Id to reference this step
+        /// </summary>
+        /// <param name="id">A custom Id to reference this step</param>
+        /// <returns></returns>
+        IStepBuilder<TData, TStepBody> Id(string id);
+
         /// <summary>
         /// Specify the next step in the workflow
         /// </summary>
@@ -51,6 +58,13 @@ public interface IStepBuilder<TData, TStepBody>
         /// <returns></returns>
         IStepBuilder<TData, ActionStepBody> Then(Action<IStepExecutionContext> body);
 
+        /// <summary>
+        /// Specify the next step in the workflow by Id
+        /// </summary>
+        /// <param name="id"></param>
+        /// <returns></returns>
+        IStepBuilder<TData, TStepBody> Attach(string id);
+
         /// <summary>
         /// Configure an outcome for this step, then wire it to another step
         /// </summary>

src/WorkflowCore/Models/StepOutcome.cs

@@ -16,7 +16,7 @@ public Expression<Func<object, object>> Value
 
         public string Label { get; set; }
 
-        public string Tag { get; set; }
+        public string ExternalNextStepId { get; set; }
 
         public object GetValue(object data)
         {

src/WorkflowCore/Models/WorkflowDefinition.cs

@@ -12,7 +12,7 @@ public class WorkflowDefinition
 
         public string Description { get; set; }
 
-        public List<WorkflowStep> Steps { get; set; }
+        public WorkflowStepCollection Steps { get; set; } = new WorkflowStepCollection();
 
         public Type DataType { get; set; }
 

src/WorkflowCore/Models/WorkflowStep.cs

@@ -14,7 +14,7 @@ public abstract class WorkflowStep
 
         public virtual string Name { get; set; }
 
-        public virtual string Tag { get; set; }
+        public virtual string ExternalId { get; set; }
 
         public virtual List<int> Children { get; set; } = new List<int>();
 

src/WorkflowCore/Models/WorkflowStepCollection.cs

@@ -0,0 +1,81 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace WorkflowCore.Models
+{
+    public class WorkflowStepCollection : ICollection<WorkflowStep>
+    {
+        private readonly Dictionary<int, WorkflowStep> _dictionary = new Dictionary<int, WorkflowStep>();
+        
+        public WorkflowStepCollection()
+        {
+        }
+
+        public WorkflowStepCollection(int capacity)
+        {
+            _dictionary = new Dictionary<int, WorkflowStep>(capacity);
+        }
+
+        public WorkflowStepCollection(ICollection<WorkflowStep> steps)
+        {
+            foreach (var step in steps)
+            {
+                Add(step);
+            }
+        }
+
+        public IEnumerator<WorkflowStep> GetEnumerator()
+        {
+            return _dictionary.Values.GetEnumerator();
+        }
+
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            return GetEnumerator();
+        }
+
+        public WorkflowStep FindById(int id)
+        {
+            if (!_dictionary.ContainsKey(id))
+                return null;
+
+            return _dictionary[id];
+        }
+        
+        public void Add(WorkflowStep item)
+        {
+            _dictionary.Add(item.Id, item);
+        }
+
+        public void Clear()
+        {
+            _dictionary.Clear();
+        }
+
+        public bool Contains(WorkflowStep item)
+        {
+            return _dictionary.ContainsValue(item);
+        }
+
+        public void CopyTo(WorkflowStep[] array, int arrayIndex)
+        {
+            _dictionary.Values.CopyTo(array, arrayIndex);
+        }
+
+        public bool Remove(WorkflowStep item)
+        {
+            return _dictionary.Remove(item.Id);
+        }
+
+        public WorkflowStep Find(Predicate<WorkflowStep> match)
+        {
+            return _dictionary.Values.FirstOrDefault(x => match(x));
+        }
+
+        public int Count => _dictionary.Count;
+        public bool IsReadOnly => false;
+    }
+}

src/WorkflowCore/Services/DefaultProviders/SingleNodeQueueProvider.cs

@@ -1,4 +1,5 @@
 using System.Collections.Concurrent;
+using System.Collections.Generic;
 using System.Threading;
 using System.Threading.Tasks;
 using WorkflowCore.Interface;
@@ -12,48 +13,42 @@ namespace WorkflowCore.Services
     /// </summary>
     public class SingleNodeQueueProvider : IQueueProvider
     {
-                
-        private readonly BlockingCollection<string> _runQueue = new BlockingCollection<string>();
-        private readonly BlockingCollection<string> _eventQueue = new BlockingCollection<string>();
+        
+        private readonly Dictionary<QueueType, BlockingCollection<string>> _queues = new Dictionary<QueueType, BlockingCollection<string>>()
+        {
+            [QueueType.Workflow] = new BlockingCollection<string>(),
+            [QueueType.Event] = new BlockingCollection<string>(),
+            [QueueType.Index] = new BlockingCollection<string>()
+        };
 
         public bool IsDequeueBlocking => true;
 
         public async Task QueueWork(string id, QueueType queue)
         {
-            SelectQueue(queue).Add(id);
+            _queues[queue].Add(id);
         }
 
         public async Task<string> DequeueWork(QueueType queue, CancellationToken cancellationToken)
         {
-            if (SelectQueue(queue).TryTake(out string id, 100, cancellationToken))
+            if (_queues[queue].TryTake(out string id, 100, cancellationToken))
                 return id;
 
             return null;
         }
 
-        public async Task Start()
+        public Task Start()
         {
+            return Task.CompletedTask;
         }
 
-        public async Task Stop()
+        public Task Stop()
         {
+            return Task.CompletedTask;
         }
 
         public void Dispose()
         {            
         }
-
-        private BlockingCollection<string> SelectQueue(QueueType queue)
-        {
-            switch (queue)
-            {
-                case QueueType.Workflow:
-                    return _runQueue;                    
-                case QueueType.Event:
-                    return _eventQueue;
-            }
-            return null;
-        }
 
     }
 

src/WorkflowCore/Services/DefinitionStorage/DefinitionLoader.cs

@@ -53,9 +53,9 @@ private WorkflowDefinition Convert(DefinitionSourceV1 source)
         }
 
 
-        private List<WorkflowStep> ConvertSteps(ICollection<StepSourceV1> source, Type dataType)
+        private WorkflowStepCollection ConvertSteps(ICollection<StepSourceV1> source, Type dataType)
         {
-            var result = new List<WorkflowStep>();
+            var result = new WorkflowStepCollection();
             int i = 0;
             var stack = new Stack<StepSourceV1>(source.Reverse<StepSourceV1>());
             var parents = new List<StepSourceV1>();
@@ -87,7 +87,7 @@ private List<WorkflowStep> ConvertSteps(ICollection<StepSourceV1> source, Type d
                 targetStep.Name = nextStep.Name;
                 targetStep.ErrorBehavior = nextStep.ErrorBehavior;
                 targetStep.RetryInterval = nextStep.RetryInterval;
-                targetStep.Tag = $"{nextStep.Id}";
+                targetStep.ExternalId = $"{nextStep.Id}";
 
                 AttachInputs(nextStep, dataType, stepType, targetStep);
                 AttachOutputs(nextStep, dataType, stepType, targetStep);
@@ -114,7 +114,7 @@ private List<WorkflowStep> ConvertSteps(ICollection<StepSourceV1> source, Type d
                 }
 
                 if (!string.IsNullOrEmpty(nextStep.NextStepId))
-                    targetStep.Outcomes.Add(new StepOutcome() { Tag = $"{nextStep.NextStepId}" });
+                    targetStep.Outcomes.Add(new StepOutcome() { ExternalNextStepId = $"{nextStep.NextStepId}" });
 
                 result.Add(targetStep);
 
@@ -123,26 +123,26 @@ private List<WorkflowStep> ConvertSteps(ICollection<StepSourceV1> source, Type d
 
             foreach (var step in result)
             {
-                if (result.Any(x => x.Tag == step.Tag && x.Id != step.Id))
-                    throw new WorkflowDefinitionLoadException($"Duplicate step Id {step.Tag}");
+                if (result.Any(x => x.ExternalId == step.ExternalId && x.Id != step.Id))
+                    throw new WorkflowDefinitionLoadException($"Duplicate step Id {step.ExternalId}");
 
                 foreach (var outcome in step.Outcomes)
                 {
-                    if (result.All(x => x.Tag != outcome.Tag))
-                        throw new WorkflowDefinitionLoadException($"Cannot find step id {outcome.Tag}");
+                    if (result.All(x => x.ExternalId != outcome.ExternalNextStepId))
+                        throw new WorkflowDefinitionLoadException($"Cannot find step id {outcome.ExternalNextStepId}");
 
-                    outcome.NextStep = result.Single(x => x.Tag == outcome.Tag).Id;
+                    outcome.NextStep = result.Single(x => x.ExternalId == outcome.ExternalNextStepId).Id;
                 }
             }
 
             foreach (var parent in parents)
             {
-                var target = result.Single(x => x.Tag == parent.Id);
+                var target = result.Single(x => x.ExternalId == parent.Id);
                 foreach (var branch in parent.Do)
                 {
                     var childTags = branch.Select(x => x.Id).ToList();
                     target.Children.AddRange(result
-                        .Where(x => childTags.Contains(x.Tag))
+                        .Where(x => childTags.Contains(x.ExternalId))
                         .OrderBy(x => x.Id)
                         .Select(x => x.Id)
                         .Take(1)
@@ -152,11 +152,11 @@ private List<WorkflowStep> ConvertSteps(ICollection<StepSourceV1> source, Type d
 
             foreach (var item in compensatables)
             {
-                var target = result.Single(x => x.Tag == item.Id);
+                var target = result.Single(x => x.ExternalId == item.Id);
                 var tag = item.CompensateWith.Select(x => x.Id).FirstOrDefault();
                 if (tag != null)
                 {
-                    var compStep = result.FirstOrDefault(x => x.Tag == tag);
+                    var compStep = result.FirstOrDefault(x => x.ExternalId == tag);
                     if (compStep != null)
                         target.CompensationStepId = compStep.Id;
                 }

src/WorkflowCore/Services/ErrorHandlers/CompensateHandler.cs

@@ -34,7 +34,7 @@ public void Handle(WorkflowInstance workflow, WorkflowDefinition def, ExecutionP
             {
                 var pointerId = scope.Pop();
                 var scopePointer = workflow.ExecutionPointers.FindById(pointerId);
-                var scopeStep = def.Steps.First(x => x.Id == scopePointer.StepId);
+                var scopeStep = def.Steps.FindById(scopePointer.StepId);
 
                 var resume = true;
                 var revert = false;
@@ -44,7 +44,7 @@ public void Handle(WorkflowInstance workflow, WorkflowDefinition def, ExecutionP
                 {
                     var parentId = txnStack.Pop();
                     var parentPointer = workflow.ExecutionPointers.FindById(parentId);
-                    var parentStep = def.Steps.First(x => x.Id == parentPointer.StepId);
+                    var parentStep = def.Steps.FindById(parentPointer.StepId);
                     if ((!parentStep.ResumeChildrenAfterCompensation) || (parentStep.RevertChildrenAfterCompensation))
                     {
                         resume = parentStep.ResumeChildrenAfterCompensation;
@@ -86,7 +86,7 @@ public void Handle(WorkflowInstance workflow, WorkflowDefinition def, ExecutionP
 
                     foreach (var siblingPointer in prevSiblings)
                     {
-                        var siblingStep = def.Steps.First(x => x.Id == siblingPointer.StepId);
+                        var siblingStep = def.Steps.FindById(siblingPointer.StepId);
                         if (siblingStep.CompensationStepId.HasValue)
                         {
                             var compensationPointer = _pointerFactory.BuildCompensationPointer(def, siblingPointer, exceptionPointer, siblingStep.CompensationStepId.Value);

src/WorkflowCore/Services/ExecutionPointerFactory.cs

@@ -17,7 +17,7 @@ public ExecutionPointer BuildGenesisPointer(WorkflowDefinition def)
                 StepId = 0,
                 Active = true,
                 Status = PointerStatus.Pending,
-                StepName = Enumerable.First<WorkflowStep>(def.Steps, x => x.Id == 0).Name
+                StepName = def.Steps.FindById(0).Name
             };
         }
 
@@ -32,7 +32,7 @@ public ExecutionPointer BuildNextPointer(WorkflowDefinition def, ExecutionPointe
                 Active = true,
                 ContextItem = pointer.ContextItem,
                 Status = PointerStatus.Pending,
-                StepName = def.Steps.First(x => x.Id == outcomeTarget.NextStep).Name,
+                StepName = def.Steps.FindById(outcomeTarget.NextStep).Name,
                 Scope = new List<string>(pointer.Scope)
             };            
         }
@@ -52,7 +52,7 @@ public ExecutionPointer BuildChildPointer(WorkflowDefinition def, ExecutionPoint
                 Active = true,
                 ContextItem = branch,
                 Status = PointerStatus.Pending,
-                StepName = def.Steps.First(x => x.Id == childDefinitionId).Name,
+                StepName = def.Steps.FindById(childDefinitionId).Name,
                 Scope = new List<string>(childScope)
             };            
         }
@@ -68,7 +68,7 @@ public ExecutionPointer BuildCompensationPointer(WorkflowDefinition def, Executi
                 Active = true,
                 ContextItem = pointer.ContextItem,
                 Status = PointerStatus.Pending,
-                StepName = def.Steps.First(x => x.Id == compensationStepId).Name,
+                StepName = def.Steps.FindById(compensationStepId).Name,
                 Scope = new List<string>(pointer.Scope)
             };
         }