Fix various DF bugs (#783)

davidmrdavid · web-flow · commit 54b90b976e1b · 2022-04-18T10:56:28.000-07:00
diff --git a/release_notes.md b/release_notes.md
@@ -1 +1,2 @@
-* Bug fix: Activity Functions can now use output bindings (https://github.com/Azure/azure-functions-powershell-worker/issues/646)
+* Bug fix: [Context.InstanceId can now be accessed](https://github.com/Azure/azure-functions-powershell-worker/issues/727)
+* Bug fix: [Data in External Events is now read and returned to orchestrator](https://github.com/Azure/azure-functions-powershell-worker/issues/68)
diff --git a/src/Durable/DurableTaskHandler.cs b/src/Durable/DurableTaskHandler.cs
@@ -47,6 +47,7 @@ public void StopAndInitiateDurableTaskOrReplay(
                     }
 
                     completedHistoryEvent.IsProcessed = true;
+                    context.IsReplaying = completedHistoryEvent.IsPlayed;
 
                     switch (completedHistoryEvent.EventType)
                     {
@@ -57,7 +58,13 @@ public void StopAndInitiateDurableTaskOrReplay(
                                 output(eventResult);
                             }
                             break;
-
+                        case HistoryEventType.EventRaised:
+                            var eventRaisedResult = GetEventResult(completedHistoryEvent);
+                            if (eventRaisedResult != null)
+                            {
+                                output(eventRaisedResult);
+                            }
+                            break;
                         case HistoryEventType.TaskFailed:
                             if (retryOptions == null)
                             {
@@ -126,6 +133,7 @@ public void WaitAll(
             var allTasksCompleted = completedEvents.Count == tasksToWaitFor.Count;
             if (allTasksCompleted)
             {
+                context.IsReplaying = completedEvents.Count == 0 ? false : completedEvents[0].IsPlayed;
                 CurrentUtcDateTimeUpdater.UpdateCurrentUtcDateTime(context);
 
                 foreach (var completedHistoryEvent in completedEvents)
@@ -164,6 +172,7 @@ public void WaitAny(
                 if (scheduledHistoryEvent != null)
                 {
                     scheduledHistoryEvent.IsProcessed = true;
+                    scheduledHistoryEvent.IsPlayed = true;
                 }
 
                 if (completedHistoryEvent != null)
@@ -179,12 +188,14 @@ public void WaitAny(
                     }
 
                     completedHistoryEvent.IsProcessed = true;
+                    completedHistoryEvent.IsPlayed = true;
                 }
             }
 
             var anyTaskCompleted = completedTasks.Count > 0;
             if (anyTaskCompleted)
             {
+                context.IsReplaying = context.History[firstCompletedHistoryEventIndex].IsPlayed;
                 CurrentUtcDateTimeUpdater.UpdateCurrentUtcDateTime(context);
                 // Return a reference to the first completed task
                 output(firstCompletedTask);
diff --git a/src/Durable/OrchestrationContext.cs b/src/Durable/OrchestrationContext.cs
@@ -20,13 +20,13 @@ public class OrchestrationContext
         public object Input { get; internal set; }
 
         [DataMember]
-        internal string InstanceId { get; set; }
+        public string InstanceId { get; set; }
 
         [DataMember]
         internal string ParentInstanceId { get; set; }
 
         [DataMember]
-        internal bool IsReplaying { get; set; }
+        public bool IsReplaying { get; set; }
 
         [DataMember]
         internal HistoryEvent[] History { get; set; }
diff --git a/src/Modules/Microsoft.Azure.Functions.PowerShellWorker/Microsoft.Azure.Functions.PowerShellWorker.psm1 b/src/Modules/Microsoft.Azure.Functions.PowerShellWorker/Microsoft.Azure.Functions.PowerShellWorker.psm1
@@ -80,6 +80,8 @@ function Get-DurableStatus {
     The input value that will be passed to the orchestration Azure Function.
 .PARAMETER DurableClient
     The orchestration client object.
+.PARAMETER InstanceId
+    The InstanceId for the new orchestration.
 #>
 function Start-DurableOrchestration {
     [CmdletBinding()]
@@ -98,7 +100,11 @@ function Start-DurableOrchestration {
 
 		[Parameter(
             ValueFromPipelineByPropertyName=$true)]
-        [object] $DurableClient
+        [object] $DurableClient,
+
+        [Parameter(
+            ValueFromPipelineByPropertyName=$true)]
+        [string] $InstanceId
     )
 
     $ErrorActionPreference = 'Stop'
@@ -107,7 +113,9 @@ function Start-DurableOrchestration {
         $DurableClient = GetDurableClientFromModulePrivateData
     }
 
-    $InstanceId = (New-Guid).Guid
+    if (-not $InstanceId) {
+        $InstanceId = (New-Guid).Guid
+    }
 
     $Uri =
         if ($DurableClient.rpcBaseUrl) {
diff --git a/test/E2E/Azure.Functions.PowerShellWorker.E2E/Azure.Functions.PowerShellWorker.E2E/DurableEndToEndTests.cs b/test/E2E/Azure.Functions.PowerShellWorker.E2E/Azure.Functions.PowerShellWorker.E2E/DurableEndToEndTests.cs
@@ -12,6 +12,7 @@ namespace Azure.Functions.PowerShell.Tests.E2E
 
     using System.Net.Http;
     using Newtonsoft.Json;
+    using System.Text;
 
     [Collection(Constants.FunctionAppCollectionName)]
     public class DurableEndToEndTests
@@ -147,6 +148,120 @@ public async Task LegacyDurableCommandNamesStillWork()
             }
         }
 
+        [Fact]
+        public async Task OrchestratationContextHasAllExpectedProperties()
+        {
+            var initialResponse = await Utilities.GetHttpTriggerResponse("DurableClientOrchContextProperties", queryString: string.Empty);
+            Assert.Equal(HttpStatusCode.Accepted, initialResponse.StatusCode);
+
+            var initialResponseBody = await initialResponse.Content.ReadAsStringAsync();
+            dynamic initialResponseBodyObject = JsonConvert.DeserializeObject(initialResponseBody);
+            var statusQueryGetUri = (string)initialResponseBodyObject.statusQueryGetUri;
+
+            var startTime = DateTime.UtcNow;
+
+            using (var httpClient = new HttpClient())
+            {
+                while (true)
+                {
+                    var statusResponse = await httpClient.GetAsync(statusQueryGetUri);
+                    switch (statusResponse.StatusCode)
+                    {
+                        case HttpStatusCode.Accepted:
+                            {
+                                var statusResponseBody = await GetResponseBodyAsync(statusResponse);
+                                var runtimeStatus = (string)statusResponseBody.runtimeStatus;
+                                Assert.True(
+                                    runtimeStatus == "Running" || runtimeStatus == "Pending",
+                                    $"Unexpected runtime status: {runtimeStatus}");
+
+                                if (DateTime.UtcNow > startTime + _orchestrationCompletionTimeout)
+                                {
+                                    Assert.True(false, $"The orchestration has not completed after {_orchestrationCompletionTimeout}");
+                                }
+
+                                await Task.Delay(TimeSpan.FromSeconds(2));
+                                break;
+                            }
+
+                        case HttpStatusCode.OK:
+                            {
+                                var statusResponseBody = await GetResponseBodyAsync(statusResponse);
+                                Assert.Equal("Completed", (string)statusResponseBody.runtimeStatus);
+                                Assert.Equal("True", statusResponseBody.output[0].ToString());
+                                Assert.Equal("Hello myInstanceId", statusResponseBody.output[1].ToString());
+                                Assert.Equal("False", statusResponseBody.output[2].ToString());
+                                return;
+                            }
+
+                        default:
+                            Assert.True(false, $"Unexpected orchestration status code: {statusResponse.StatusCode}");
+                            break;
+                    }
+                }
+            }
+        }
+
+        [Fact]
+        public async Task ExternalEventReturnsData()
+        {
+            var initialResponse = await Utilities.GetHttpTriggerResponse("DurableClient", queryString: "?FunctionName=DurableOrchestratorRaiseEvent");
+            Assert.Equal(HttpStatusCode.Accepted, initialResponse.StatusCode);
+
+            var initialResponseBody = await initialResponse.Content.ReadAsStringAsync();
+            dynamic initialResponseBodyObject = JsonConvert.DeserializeObject(initialResponseBody);
+            var statusQueryGetUri = (string)initialResponseBodyObject.statusQueryGetUri;
+            var raiseEventUri = (string)initialResponseBodyObject.sendEventPostUri;
+
+            raiseEventUri = raiseEventUri.Replace("{eventName}", "TESTEVENTNAME");
+
+            var startTime = DateTime.UtcNow;
+
+            using (var httpClient = new HttpClient())
+            {
+                while (true)
+                {
+                    // Send external event payload
+                    var json = JsonConvert.SerializeObject("helloWorld!");
+                    var httpContent = new StringContent(json, Encoding.UTF8, "application/json");
+                    await httpClient.PostAsync(raiseEventUri, httpContent);
+
+                    var statusResponse = await httpClient.GetAsync(statusQueryGetUri);
+                    switch (statusResponse.StatusCode)
+                    {
+                        case HttpStatusCode.Accepted:
+                            {
+                                var statusResponseBody = await GetResponseBodyAsync(statusResponse);
+                                var runtimeStatus = (string)statusResponseBody.runtimeStatus;
+                                Assert.True(
+                                    runtimeStatus == "Running" || runtimeStatus == "Pending",
+                                    $"Unexpected runtime status: {runtimeStatus}");
+
+                                if (DateTime.UtcNow > startTime + _orchestrationCompletionTimeout)
+                                {
+                                    Assert.True(false, $"The orchestration has not completed after {_orchestrationCompletionTimeout}");
+                                }
+
+                                await Task.Delay(TimeSpan.FromSeconds(2));
+                                break;
+                            }
+
+                        case HttpStatusCode.OK:
+                            {
+                                var statusResponseBody = await GetResponseBodyAsync(statusResponse);
+                                Assert.Equal("Completed", (string)statusResponseBody.runtimeStatus);
+                                Assert.Equal("helloWorld!", statusResponseBody.output.ToString());
+                                return;
+                            }
+
+                        default:
+                            Assert.True(false, $"Unexpected orchestration status code: {statusResponse.StatusCode}");
+                            break;
+                    }
+                }
+            }
+        }
+
         [Fact]
         public async Task ActivityCanHaveQueueBinding()
         {
diff --git a/test/E2E/TestFunctionApp/DurableClientOrchContextProperties/function.json b/test/E2E/TestFunctionApp/DurableClientOrchContextProperties/function.json
@@ -0,0 +1,24 @@
+{
+  "bindings": [
+    {
+      "authLevel": "function",
+      "name": "Request",
+      "type": "httpTrigger",
+      "direction": "in",
+      "methods": [
+        "post",
+        "get"
+      ]
+    },
+    {
+      "type": "http",
+      "direction": "out",
+      "name": "Response"
+    },
+    {
+      "name": "starter",
+      "type": "durableClient",
+      "direction": "in"
+    }
+  ]
+}
diff --git a/test/E2E/TestFunctionApp/DurableClientOrchContextProperties/run.ps1 b/test/E2E/TestFunctionApp/DurableClientOrchContextProperties/run.ps1
@@ -0,0 +1,9 @@
+using namespace System.Net
+
+param($Request, $TriggerMetadata)
+
+$InstanceId = Start-DurableOrchestration -FunctionName "DurableOrchestratorAccessContextProps" -InstanceId "myInstanceId"
+Write-Host "Started orchestration with ID = '$InstanceId'"
+
+$Response = New-DurableOrchestrationCheckStatusResponse -Request $Request -InstanceId $InstanceId
+Push-OutputBinding -Name Response -Value $Response
diff --git a/test/E2E/TestFunctionApp/DurableOrchestratorAccessContextProps/function.json b/test/E2E/TestFunctionApp/DurableOrchestratorAccessContextProps/function.json
@@ -0,0 +1,9 @@
+{
+  "bindings": [
+    {
+      "name": "Context",
+      "type": "orchestrationTrigger",
+      "direction": "in"
+    }
+  ]
+}
diff --git a/test/E2E/TestFunctionApp/DurableOrchestratorAccessContextProps/run.ps1 b/test/E2E/TestFunctionApp/DurableOrchestratorAccessContextProps/run.ps1
@@ -0,0 +1,8 @@
+param($Context)
+
+$output = @()
+
+$output += $Context.IsReplaying
+$output += Invoke-DurableActivity -FunctionName 'DurableActivity' -Input $Context.InstanceId
+$output += $Context.IsReplaying
+$output
diff --git a/test/E2E/TestFunctionApp/DurableOrchestratorRaiseEvent/function.json b/test/E2E/TestFunctionApp/DurableOrchestratorRaiseEvent/function.json
@@ -0,0 +1,9 @@
+{
+  "bindings": [
+    {
+      "name": "Context",
+      "type": "orchestrationTrigger",
+      "direction": "in"
+    }
+  ]
+}
diff --git a/test/E2E/TestFunctionApp/DurableOrchestratorRaiseEvent/run.ps1 b/test/E2E/TestFunctionApp/DurableOrchestratorRaiseEvent/run.ps1
@@ -0,0 +1,7 @@
+param($Context)
+
+$output = @()
+
+$output += Start-DurableExternalEventListener -EventName "TESTEVENTNAME" 
+
+$output

Original file line number	Diff line number	Diff line change
`@@ -1 +1,2 @@`
`1`		`-* Bug fix: Activity Functions can now use output bindings (https://github.com/Azure/azure-functions-powershell-worker/issues/646)`
	`1`	`+* Bug fix: [Context.InstanceId can now be accessed](https://github.com/Azure/azure-functions-powershell-worker/issues/727)`
	`2`	`+* Bug fix: [Data in External Events is now read and returned to orchestrator](https://github.com/Azure/azure-functions-powershell-worker/issues/68)`
Original file line number	Diff line number	Diff line change
`@@ -47,6 +47,7 @@ public void StopAndInitiateDurableTaskOrReplay(`
`47`	`47`	`}`
`48`	`48`
`49`	`49`	`completedHistoryEvent.IsProcessed = true;`
	`50`	`+ context.IsReplaying = completedHistoryEvent.IsPlayed;`
`50`	`51`
`51`	`52`	`switch (completedHistoryEvent.EventType)`
`52`	`53`	`{`
`@@ -57,7 +58,13 @@ public void StopAndInitiateDurableTaskOrReplay(`
`57`	`58`	`output(eventResult);`
`58`	`59`	`}`
`59`	`60`	`break;`
`60`		`-`
	`61`	`+ case HistoryEventType.EventRaised:`
	`62`	`+ var eventRaisedResult = GetEventResult(completedHistoryEvent);`
	`63`	`+ if (eventRaisedResult != null)`
	`64`	`+ {`
	`65`	`+ output(eventRaisedResult);`
	`66`	`+ }`
	`67`	`+ break;`
`61`	`68`	`case HistoryEventType.TaskFailed:`
`62`	`69`	`if (retryOptions == null)`
`63`	`70`	`{`
`@@ -126,6 +133,7 @@ public void WaitAll(`
`126`	`133`	`var allTasksCompleted = completedEvents.Count == tasksToWaitFor.Count;`
`127`	`134`	`if (allTasksCompleted)`
`128`	`135`	`{`
	`136`	`+ context.IsReplaying = completedEvents.Count == 0 ? false : completedEvents[0].IsPlayed;`
`129`	`137`	`CurrentUtcDateTimeUpdater.UpdateCurrentUtcDateTime(context);`
`130`	`138`
`131`	`139`	`foreach (var completedHistoryEvent in completedEvents)`
`@@ -164,6 +172,7 @@ public void WaitAny(`
`164`	`172`	`if (scheduledHistoryEvent != null)`
`165`	`173`	`{`
`166`	`174`	`scheduledHistoryEvent.IsProcessed = true;`
	`175`	`+ scheduledHistoryEvent.IsPlayed = true;`
`167`	`176`	`}`
`168`	`177`
`169`	`178`	`if (completedHistoryEvent != null)`
`@@ -179,12 +188,14 @@ public void WaitAny(`
`179`	`188`	`}`
`180`	`189`
`181`	`190`	`completedHistoryEvent.IsProcessed = true;`
	`191`	`+ completedHistoryEvent.IsPlayed = true;`
`182`	`192`	`}`
`183`	`193`	`}`
`184`	`194`
`185`	`195`	`var anyTaskCompleted = completedTasks.Count > 0;`
`186`	`196`	`if (anyTaskCompleted)`
`187`	`197`	`{`
	`198`	`+ context.IsReplaying = context.History[firstCompletedHistoryEventIndex].IsPlayed;`
`188`	`199`	`CurrentUtcDateTimeUpdater.UpdateCurrentUtcDateTime(context);`
`189`	`200`	`// Return a reference to the first completed task`
`190`	`201`	`output(firstCompletedTask);`