Rename Durable commands (#625)

* Rename Invoke-ActivityFunction to Invoke-DurableActivity

* Add Invoke-ActivityFunction alias

* Use Invoke-DurableActivity in tests and examples

* Rename New-OrchestrationCheckStatusResponse to New-DurableOrchestrationCheckStatusResponse

* Add alias for New-OrchestrationCheckStatusResponse

* Replace New-OrchestrationCheckStatusResponse with New-DurableOrchestrationCheckStatusResponse in tests and examples

* Rename Start-NewOrchestration to Start-DurableOrchestration

* Add Start-NewOrchestration alias

* Replace Start-NewOrchestration with Start-DurableOrchestration in tests and examples

* Add E2E test using old command names

Author: AnatoliB

docs/designs/PowerShell-AzF-Overall-Design.md

@@ -551,17 +551,17 @@ We had a prototype of Durable Functions in PowerShell worker to enable the '_Fun
 2. Make the orchestrator function able to be stopped at certain point safely.
 3. Make the PowerShell worker able to replay an orchestrator function, namely skipping the actions that are done in previous runs/replays based on the save logs.
 
-They were solved by introducing the new cmdlet "_Invoke-ActivityFunction_" plus having the worker invoke the orchestrator function with the async PowerShell API.
+They were solved by introducing the new cmdlet "_Invoke-DurableActivity_" plus having the worker invoke the orchestrator function with the async PowerShell API.
 
 Internally, the worker shares context information with the cmdlet, including _the existing saved logs_ sent from the host about the running orchestrator function and _a wait handler_ - let's call it A - which the cmdlet will set after it triggers an activity function. The async API used to start the orchestrator function returns _another wait handler_ - let's call it B - which will be set when the invocation finishes. Then the invoking thread will call '_WaitHandler.WaitAny_' on those two wait handlers.
 
 - If the call to '_WaitAny_' returns because the wait handler A was set, then that means an activity function was just triggered, and the orchestrator function should be stopped now (it will be triggered again later after the activity function finishes). So, in this case, the invoking thread will stop the orchestrator function that is running asynchronously.
 - If the call to '_WaitAny_' returns because the wait handler B was set, then that means the orchestrator function has run to its completion.
 
-The cmdlet '_Invoke-ActivityFunction_' has the following syntax, the '_-FunctionName_' being the name of the activity function to invoke and '_-Input_' being the argument to the activity function.
+The cmdlet '_Invoke-DurableActivity_' has the following syntax, the '_-FunctionName_' being the name of the activity function to invoke and '_-Input_' being the argument to the activity function.
 
 ```powershell
-Invoke-ActivityFunction [-FunctionName] <string> [[-Input] <Object>] [<CommonParameters>]
+Invoke-DurableActivity [-FunctionName] <string> [[-Input] <Object>] [<CommonParameters>]
 ```
 
 When it's invoked to trigger an activity function, it first checks the existing logs shared by the worker to see if this invocation of the activity function has already done previously. If so, the cmdlet simply returns the result. If not, the cmdlet will
@@ -570,7 +570,7 @@ When it's invoked to trigger an activity function, it first checks the existing
 - set the wait handler shared by the worker to notify the worker that the activity function is triggered;
 - wait on a private wait handler that will only be set when the '_StopProcessing_' method of the cmdlet is called. That method gets called only when the pipeline where this cmdlet is running in is being stopped.
 
-The third step is very important in this stop-and-replay model of Durable Functions, because when stopping an invocation that is running asynchronously, we don't want that to interrupt arbitrary code execution that is happening in the pipeline. By having the cmdlet '_Invoke-ActivityFunction_' wait for '_StopProcessing_' to be called, we know for sure that the pipeline execution pauses at a safe place, ready for being stopped by the invoking thread.
+The third step is very important in this stop-and-replay model of Durable Functions, because when stopping an invocation that is running asynchronously, we don't want that to interrupt arbitrary code execution that is happening in the pipeline. By having the cmdlet '_Invoke-DurableActivity_' wait for '_StopProcessing_' to be called, we know for sure that the pipeline execution pauses at a safe place, ready for being stopped by the invoking thread.
 
 The following is an example of PowerShell Durable Function that runs in the Function Chaining pattern:
 
@@ -583,9 +583,9 @@ param($context)
 
 $output = @()
 
-$output += Invoke-ActivityFunction -FunctionName "E1_SayHello" -Input "Tokyo"
-$output += Invoke-ActivityFunction -FunctionName "E1_SayHello" -Input "Seattle"
-$output += Invoke-ActivityFunction -FunctionName "E1_SayHello" -Input "London"
+$output += Invoke-DurableActivity -FunctionName "E1_SayHello" -Input "Tokyo"
+$output += Invoke-DurableActivity -FunctionName "E1_SayHello" -Input "Seattle"
+$output += Invoke-DurableActivity -FunctionName "E1_SayHello" -Input "London"
 
 return $output
 ```

examples/durable/DurableApp/CustomStatusOrchestrator/run.ps1

@@ -7,13 +7,13 @@ Write-Host 'CustomStatusOrchestrator: started.'
 $output = @()
 
 Set-DurableCustomStatus -CustomStatus 'Processing Tokyo'
-$output += Invoke-ActivityFunction -FunctionName 'SayHello' -Input 'Tokyo'
+$output += Invoke-DurableActivity -FunctionName 'SayHello' -Input 'Tokyo'
 
 Set-DurableCustomStatus -CustomStatus @{ ProgressMessage = 'Processing Seattle'; Stage = 2 }
-$output += Invoke-ActivityFunction -FunctionName 'SayHello' -Input 'Seattle'
+$output += Invoke-DurableActivity -FunctionName 'SayHello' -Input 'Seattle'
 
 Set-DurableCustomStatus -CustomStatus @('Processing London', 'Last stage')
-$output += Invoke-ActivityFunction -FunctionName 'SayHello' -Input 'London'
+$output += Invoke-DurableActivity -FunctionName 'SayHello' -Input 'London'
 
 Set-DurableCustomStatus 'Processing completed'
 

examples/durable/DurableApp/FanOutFanInOrchestrator/run.ps1

@@ -6,7 +6,7 @@ Write-Host 'FanOutFanInOrchestrator: started.'
 
 $parallelTasks =
     foreach ($Name in 'Tokyo', 'Seattle', 'London') {
-        Invoke-ActivityFunction -FunctionName 'SayHello' -Input $Name -NoWait
+        Invoke-DurableActivity -FunctionName 'SayHello' -Input $Name -NoWait
     }
 
 $output = Wait-DurableTask -Task $parallelTasks

examples/durable/DurableApp/FunctionChainingOrchestrator/run.ps1

@@ -6,9 +6,9 @@ Write-Host 'FunctionChainingOrchestrator: started.'
 
 $output = @()
 
-$output += Invoke-ActivityFunction -FunctionName 'SayHello' -Input 'Tokyo'
-$output += Invoke-ActivityFunction -FunctionName 'SayHello' -Input 'Seattle'
-$output += Invoke-ActivityFunction -FunctionName 'SayHello' -Input 'London'
+$output += Invoke-DurableActivity -FunctionName 'SayHello' -Input 'Tokyo'
+$output += Invoke-DurableActivity -FunctionName 'SayHello' -Input 'Seattle'
+$output += Invoke-DurableActivity -FunctionName 'SayHello' -Input 'London'
 
 Write-Host 'FunctionChainingOrchestrator: finished.'
 

examples/durable/DurableApp/FunctionChainingWithRetriesOrchestrator/run.ps1

@@ -10,8 +10,8 @@ $retryOptions = New-DurableRetryOptions `
                     -FirstRetryInterval (New-Timespan -Seconds 1) `
                     -MaxNumberOfAttempts 7
 
-$output += Invoke-ActivityFunction -FunctionName 'FlakyActivity' -Input 'Tokyo' -RetryOptions $retryOptions
-$output += Invoke-ActivityFunction -FunctionName 'FlakyActivity' -Input 'Seattle' -RetryOptions $retryOptions
-$output += Invoke-ActivityFunction -FunctionName 'FlakyActivity' -Input 'London' -RetryOptions $retryOptions
+$output += Invoke-DurableActivity -FunctionName 'FlakyActivity' -Input 'Tokyo' -RetryOptions $retryOptions
+$output += Invoke-DurableActivity -FunctionName 'FlakyActivity' -Input 'Seattle' -RetryOptions $retryOptions
+$output += Invoke-DurableActivity -FunctionName 'FlakyActivity' -Input 'London' -RetryOptions $retryOptions
 
 $output

examples/durable/DurableApp/HttpStart/run.ps1

@@ -4,10 +4,10 @@ param($Request, $TriggerMetadata)
 
 Write-Host 'HttpStart started'
 
-$InstanceId = Start-NewOrchestration -FunctionName $Request.Params.FunctionName -InputObject $Request.Query.Input
+$InstanceId = Start-DurableOrchestration -FunctionName $Request.Params.FunctionName -InputObject $Request.Query.Input
 Write-Host "Started orchestration $($Request.Params.FunctionName) with ID = '$InstanceId'"
 
-$Response = New-OrchestrationCheckStatusResponse -Request $Request -InstanceId $InstanceId
+$Response = New-DurableOrchestrationCheckStatusResponse -Request $Request -InstanceId $InstanceId
 Push-OutputBinding -Name Response -Value $Response
 
 Write-Host 'HttpStart completed'

examples/durable/DurableApp/HumanInteractionOrchestrator/run.ps1

@@ -10,7 +10,7 @@ $duration = New-TimeSpan -Seconds $Context.Input.Duration
 $managerId = $Context.Input.ManagerId
 $skipManagerId = $Context.Input.SkipManagerId
 
-$output += Invoke-ActivityFunction -FunctionName "RequestApproval" -Input $managerId
+$output += Invoke-DurableActivity -FunctionName "RequestApproval" -Input $managerId
 
 $durableTimeoutEvent = Start-DurableTimer -Duration $duration -NoWait
 $approvalEvent = Start-DurableExternalEventListener -EventName "ApprovalEvent" -NoWait
@@ -19,10 +19,10 @@ $firstEvent = Wait-DurableTask -Task @($approvalEvent, $durableTimeoutEvent) -An
 
 if ($approvalEvent -eq $firstEvent) {
     Stop-DurableTimerTask -Task $durableTimeoutEvent
-    $output += Invoke-ActivityFunction -FunctionName "ProcessApproval" -Input $approvalEvent
+    $output += Invoke-DurableActivity -FunctionName "ProcessApproval" -Input $approvalEvent
 }
 else {
-    $output += Invoke-ActivityFunction -FunctionName "EscalateApproval" -Input $skipManagerId
+    $output += Invoke-DurableActivity -FunctionName "EscalateApproval" -Input $skipManagerId
 }
 
 Write-Host 'HumanInteractionOrchestrator: finished.'

examples/durable/DurableApp/HumanInteractionStart/run.ps1

@@ -6,10 +6,10 @@ Write-Host 'HumanInteractionStart started'
 
 $OrchestratorInputs = @{ Duration = 45; ManagerId = 1; SkipManagerId = 2 }
 
-$InstanceId = Start-NewOrchestration -FunctionName 'HumanInteractionOrchestrator' -InputObject $OrchestratorInputs
+$InstanceId = Start-DurableOrchestration -FunctionName 'HumanInteractionOrchestrator' -InputObject $OrchestratorInputs
 Write-Host "Started orchestration with ID = '$InstanceId'"
 
-$Response = New-OrchestrationCheckStatusResponse -Request $Request -InstanceId $InstanceId
+$Response = New-DurableOrchestrationCheckStatusResponse -Request $Request -InstanceId $InstanceId
 Push-OutputBinding -Name Response -Value $Response
 
 Write-Host 'HumanInteractionStart completed'

examples/durable/DurableApp/MonitorOrchestrator/run.ps1

@@ -12,10 +12,10 @@ $pollingInterval = New-TimeSpan -Seconds $Context.Input.PollingInterval
 $expiryTime = $Context.Input.ExpiryTime
 
 while ($Context.CurrentUtcDateTime -lt $expiryTime) {
-    $jobStatus = Invoke-ActivityFunction -FunctionName 'GetJobStatus' -Input $jobId
+    $jobStatus = Invoke-DurableActivity -FunctionName 'GetJobStatus' -Input $jobId
     if ($jobStatus -eq "Completed") {
         # Perform an action when a condition is met.
-        $output += Invoke-ActivityFunction -FunctionName 'SendAlert' -Input $machineId
+        $output += Invoke-DurableActivity -FunctionName 'SendAlert' -Input $machineId
         break
     }
 

examples/durable/DurableApp/MonitorStart/run.ps1

@@ -6,10 +6,10 @@ Write-Host 'MonitorStart started'
 
 $OrchestratorInputs = @{ JobId = 1; MachineId = 1; PollingInterval = 10; ExpiryTime = (Get-Date).ToUniversalTime().AddSeconds(60) }
 
-$InstanceId = Start-NewOrchestration -FunctionName 'MonitorOrchestrator' -InputObject $OrchestratorInputs
+$InstanceId = Start-DurableOrchestration -FunctionName 'MonitorOrchestrator' -InputObject $OrchestratorInputs
 Write-Host "Started orchestration with ID = '$InstanceId'"
 
-$Response = New-OrchestrationCheckStatusResponse -Request $Request -InstanceId $InstanceId
+$Response = New-DurableOrchestrationCheckStatusResponse -Request $Request -InstanceId $InstanceId
 Push-OutputBinding -Name Response -Value $Response
 
 Write-Host 'MonitorStart completed'