feat(sdk-dotnet): implement retries in task nodes and timeouts in external events

sdk-dotnet/LittleHorse.Sdk.Tests/Workflow/Spec/LHVariableAssigmentTest.cs

@@ -55,7 +55,7 @@ public void VariableAssigment_WithWfRunVariableContainingJson_ShouldAssignDetail
     public void VariableAssigment_WithNodeOutput_ShouldAssignNodeOutputToVariable()
     {
        var nodeOutput = new NodeOutput("wait-to-collect-order-data", _parentWfThread);
-       nodeOutput.JsonPath = "$.order";
+       nodeOutput.WithJsonPath("$.order");
 
        var variableAssigment = _parentWfThread.AssignVariableHelper(nodeOutput);
 

sdk-dotnet/LittleHorse.Sdk.Tests/Workflow/Spec/WorkflowThreadTaskRetriesTest.cs

@@ -0,0 +1,66 @@
+using System;
+using LittleHorse.Sdk.Common.Proto;
+using LittleHorse.Sdk.Workflow.Spec;
+using Moq;
+using Xunit;
+
+namespace LittleHorse.Sdk.Tests.Workflow.Spec;
+
+public class WorkflowThreadTaskRetriesTest
+{
+    private Action<WorkflowThread> _action;
+    void ParentEntrypoint(WorkflowThread thread)
+    {
+    }
+
+    public WorkflowThreadTaskRetriesTest()
+    {
+        LHLoggerFactoryProvider.Initialize(null);
+        _action = ParentEntrypoint;
+    }
+
+    [Fact]
+    public void WfThread_WithRetriesInTaskNode_ShouldCompile()
+    {
+        var numberOfExitNodes = 1;
+        var numberOfEntrypointNodes = 1;
+        var numberOfTasks = 1;
+        var workflowName = "TestWorkflow";
+        var mockParentWorkflow = new Mock<Sdk.Workflow.Spec.Workflow>(workflowName, _action);
+        void EntryPointAction(WorkflowThread wf)
+        {
+            wf.Execute("greet").WithRetries(2);
+        }
+        var workflowThread = new WorkflowThread(mockParentWorkflow.Object, EntryPointAction);
+
+        var compiledWfThread = workflowThread.Compile();
+
+        var expectedSpec = new ThreadSpec();
+
+        var entrypoint = new Node
+        {
+            Entrypoint = new EntrypointNode(),
+            OutgoingEdges = { new Edge { SinkNodeName = "1-greet-TASK" } }
+        };
+
+        var greetTask = new Node
+        {
+            Task = new TaskNode
+            {
+                TaskDefId = new TaskDefId { Name = "greet" },
+                Retries = 2
+            },
+            OutgoingEdges = { new Edge { SinkNodeName = "2-exit-EXIT" } }
+        };
+
+        var exitNode = new Node { Exit = new ExitNode() };
+
+        expectedSpec.Nodes.Add("0-entrypoint-ENTRYPOINT", entrypoint);
+        expectedSpec.Nodes.Add("1-greet-TASK", greetTask);
+        expectedSpec.Nodes.Add("2-exit-EXIT", exitNode);
+
+        var expectedNumberOfNodes = numberOfEntrypointNodes + numberOfExitNodes + numberOfTasks;
+        Assert.Equal(expectedNumberOfNodes, compiledWfThread.Nodes.Count);
+        Assert.Equal(expectedSpec, compiledWfThread);
+    }
+}

sdk-dotnet/LittleHorse.Sdk.Tests/Workflow/Spec/WorkflowThreadTest.cs

@@ -156,18 +156,19 @@ void EntryPointAction(WorkflowThread wf)
     }
 
     [Fact]
-    public void WfThread_WithExternalEvent_ShouldCompileItInTheWorkflowThread()
+    public void WfThread_WithExternalEvent_ShouldCompile()
     {
         var numberOfExitNodes = 1;
         var numberOfEntrypointNodes = 1;
         var numberOfExternalEvents = 1;
         var numberOfTasks = 1;
         var workflowName = "TestWorkflow";
+        var timeoutInSeconds = 30;
         var mockParentWorkflow = new Mock<Sdk.Workflow.Spec.Workflow>(workflowName, _action);
         void EntryPointAction(WorkflowThread wf)
         {
             WfRunVariable name = wf.DeclareStr("name");
-            name.Assign(wf.WaitForEvent("name-event"));
+            name.Assign(wf.WaitForEvent("name-event").WithTimeout(timeoutInSeconds));
             wf.Execute("greet", name);
         }
         var workflowThread = new WorkflowThread(mockParentWorkflow.Object, EntryPointAction);
@@ -188,7 +189,8 @@ void EntryPointAction(WorkflowThread wf)
         {
             ExternalEvent = new ExternalEventNode
             {
-                ExternalEventDefId = new ExternalEventDefId { Name = "name-event" }
+                ExternalEventDefId = new ExternalEventDefId { Name = "name-event" },
+                TimeoutSeconds = new VariableAssignment { LiteralValue = new VariableValue { Int = timeoutInSeconds }}
             },
             OutgoingEdges =
             {

sdk-dotnet/LittleHorse.Sdk/Workflow/Spec/NodeOutput.cs

@@ -2,9 +2,9 @@ namespace LittleHorse.Sdk.Workflow.Spec;
 
 public class NodeOutput
 {
-    public string NodeName { get; set; }
-    public WorkflowThread Parent { get; set; }
-    public string? JsonPath { get; set; }
+    public string NodeName { get; private set; }
+    public WorkflowThread Parent { get; private set; }
+    public string? JsonPath { get; private set; }
 
     public NodeOutput(string nodeName, WorkflowThread parent)
     {
@@ -23,4 +23,11 @@ public NodeOutput WithJsonPath(string path)
 
         return nodeOutput;
     }
+
+    public NodeOutput WithTimeout(int timeoutSeconds) 
+    {
+        Parent.AddTimeoutToExtEvt(this, timeoutSeconds);
+
+        return this;
+    }
 }

sdk-dotnet/LittleHorse.Sdk/Workflow/Spec/TaskNodeOutput.cs

@@ -0,0 +1,22 @@
+using LittleHorse.Sdk.Common.Proto;
+
+namespace LittleHorse.Sdk.Workflow.Spec;
+
+public class TaskNodeOutput : NodeOutput
+{
+    public TaskNodeOutput(string nodeName, WorkflowThread parent) : base(nodeName, parent)
+    {
+    }
+
+    public TaskNodeOutput WithExponentialBackoff(ExponentialBackoffRetryPolicy policy)
+    {
+        Parent.OverrideTaskExponentialBackoffPolicy(this, policy);
+        return this;
+    }
+
+    public TaskNodeOutput WithRetries(int retries) 
+    {
+        Parent.OverrideTaskRetries(this, retries);
+        return this;
+    }
+}

sdk-dotnet/LittleHorse.Sdk/Workflow/Spec/WorkflowThread.cs

@@ -182,15 +182,15 @@ public WfRunVariable AddVariable(string name, Object typeOrDefaultVal)
     /// pass that literal value in.
     /// </param>
     /// <returns>A NodeOutput for that TASK node.</returns>
-    public NodeOutput Execute(string taskName, params object[] args) 
+    public TaskNodeOutput Execute(string taskName, params object[] args) 
     {
         CheckIfWorkflowThreadIsActive();
         _parent.AddTaskDefName(taskName);
         var taskNode = CreateTaskNode(
             new TaskNode { TaskDefId = new TaskDefId { Name = taskName } }, args);
         string nodeName = AddNode(taskName, Node.NodeOneofCase.Task, taskNode);
 
-        return new NodeOutput(nodeName, this);
+        return new TaskNodeOutput(nodeName, this);
     }
 
     private VariableAssignment AssignVariable(Object variable) 
@@ -522,4 +522,55 @@ internal VariableAssignment AssignVariableHelper(object? value)
 
         return variableAssignment;
     }
+
+    internal void AddTimeoutToExtEvt(NodeOutput node, int timeoutSeconds) 
+    {
+        CheckIfWorkflowThreadIsActive();
+        Node newNode = FindNode(node.NodeName);
+
+        var timeoutValue = new VariableAssignment
+        {
+            LiteralValue = new VariableValue { Int = timeoutSeconds }
+        };
+
+        if (newNode.NodeCase == Node.NodeOneofCase.Task)
+        {
+            newNode.Task.TimeoutSeconds = timeoutSeconds;
+        } 
+        else if (newNode.NodeCase == Node.NodeOneofCase.ExternalEvent) 
+        {
+            newNode.ExternalEvent.TimeoutSeconds = timeoutValue;
+        } 
+        else 
+        {
+            throw new Exception("Timeouts are only supported on ExternalEvent and Task nodes.");
+        }
+    }
+
+    internal void OverrideTaskExponentialBackoffPolicy(TaskNodeOutput node, ExponentialBackoffRetryPolicy policy)
+    {
+        var newNode = CheckTaskNode(node);
+
+        newNode.Task.ExponentialBackoff = policy;
+    }
+
+    internal void OverrideTaskRetries(TaskNodeOutput node, int retries) 
+    {
+        var newNode = CheckTaskNode(node);
+
+        newNode.Task.Retries = retries;
+    }
+
+    private Node CheckTaskNode(TaskNodeOutput node)
+    {
+        CheckIfWorkflowThreadIsActive();
+        Node newNode = FindNode(node.NodeName);
+
+        if (newNode.NodeCase != Node.NodeOneofCase.Task) 
+        {
+            throw new InvalidOperationException("Impossible to not have task node here");
+        }
+
+        return newNode;
+    }
 }