Enable external DF SDK

src/DurableSDK/ExternalInvoker.cs

@@ -0,0 +1,28 @@
+//
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+//
+
+namespace Microsoft.Azure.Functions.PowerShellWorker.Durable
+{
+    using System;
+    using System.Collections;
+    using System.Management.Automation;
+
+    // Contract for the orchestration invoker in the external Durable Functions SDK
+    internal class ExternalInvoker : IExternalOrchestrationInvoker
+    {
+        private readonly Func<PowerShell, object> _externalSDKInvokerFunction;
+
+        public ExternalInvoker(Func<PowerShell, object> invokerFunction)
+        {
+            _externalSDKInvokerFunction = invokerFunction;
+        }
+
+        // Invokes an orchestration using the external Durable SDK
+        public Hashtable Invoke(IPowerShellServices powerShellServices)
+        {
+            return (Hashtable)_externalSDKInvokerFunction.Invoke(powerShellServices.GetPowerShell());
+        }
+    }
+}

src/DurableSDK/IExternalOrchestrationInvoker.cs

@@ -0,0 +1,16 @@
+//
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+//
+
+namespace Microsoft.Azure.Functions.PowerShellWorker.Durable
+{
+    using System.Collections;
+
+    // Contract interface for the orchestration invoker in the external Durable Functions SDK
+    internal interface IExternalOrchestrationInvoker
+    {
+        // Invokes an orchestration using the external Durable SDK
+        Hashtable Invoke(IPowerShellServices powerShellServices);
+    }
+}

src/DurableSDK/IOrchestrationInvoker.cs

@@ -10,5 +10,6 @@ namespace Microsoft.Azure.Functions.PowerShellWorker.Durable
     internal interface IOrchestrationInvoker
     {
         Hashtable Invoke(OrchestrationBindingInfo orchestrationBindingInfo, IPowerShellServices pwsh);
+        void SetExternalInvoker(IExternalOrchestrationInvoker externalInvoker);
     }
 }

src/DurableSDK/IPowerShellServices.cs

@@ -5,17 +5,30 @@
 
 namespace Microsoft.Azure.Functions.PowerShellWorker.Durable
 {
+    using Microsoft.Azure.WebJobs.Script.Grpc.Messages;
     using System;
     using System.Management.Automation;
 
     internal interface IPowerShellServices
     {
+        PowerShell GetPowerShell();
+
+        bool HasExternalDurableSDK();
+
+        bool isExternalDurableSdkLoaded();
+
+        void EnableExternalDurableSDK();
+
         void SetDurableClient(object durableClient);
 
-        void SetOrchestrationContext(OrchestrationContext orchestrationContext);
+        OrchestrationBindingInfo SetOrchestrationContext(ParameterBinding context, out IExternalOrchestrationInvoker externalInvoker);
 
         void ClearOrchestrationContext();
 
+        void TracePipelineObject();
+
+        void AddParameter(string name, object value);
+
         IAsyncResult BeginInvoke(PSDataCollection<object> output);
 
         void EndInvoke(IAsyncResult asyncResult);

src/DurableSDK/OrchestrationInvoker.cs

@@ -11,58 +11,97 @@ namespace Microsoft.Azure.Functions.PowerShellWorker.Durable
     using System.Linq;
     using System.Management.Automation;
 
-    using PowerShellWorker.Utility;
     using Microsoft.Azure.Functions.PowerShellWorker.Durable.Actions;
+    using Microsoft.Azure.Functions.PowerShellWorker.Utility;
 
     internal class OrchestrationInvoker : IOrchestrationInvoker
     {
-        public Hashtable Invoke(OrchestrationBindingInfo orchestrationBindingInfo, IPowerShellServices pwsh)
+        private IExternalOrchestrationInvoker externalInvoker;
+
+        public Hashtable Invoke(
+            OrchestrationBindingInfo orchestrationBindingInfo,
+            IPowerShellServices powerShellServices)
         {
             try
             {
-                var outputBuffer = new PSDataCollection<object>();
-                var context = orchestrationBindingInfo.Context;
+                if (powerShellServices.HasExternalDurableSDK())
+                {
+                    return InvokeExternalDurableSDK(powerShellServices);
+                }
+                return InvokeInternalDurableSDK(orchestrationBindingInfo, powerShellServices);
+            }
+            catch (Exception ex)
+            {
+                ex.Data.Add(Utils.IsOrchestrationFailureKey, true);
+                throw;
+            }
+            finally
+            {
+                powerShellServices.ClearStreamsAndCommands();
+            }
+        }
+
+        public Hashtable InvokeExternalDurableSDK(IPowerShellServices powerShellServices)
+        {
+            return externalInvoker.Invoke(powerShellServices);
+        }
+
+        public Hashtable InvokeInternalDurableSDK(
+            OrchestrationBindingInfo orchestrationBindingInfo,
+            IPowerShellServices powerShellServices)
+        {
+            var outputBuffer = new PSDataCollection<object>();
+            var context = orchestrationBindingInfo.Context;
+
+            // context.History should never be null when initializing CurrentUtcDateTime
+            var orchestrationStart = context.History.First(
+                e => e.EventType == HistoryEventType.OrchestratorStarted);
+            context.CurrentUtcDateTime = orchestrationStart.Timestamp.ToUniversalTime();
 
-                // context.History should never be null when initializing CurrentUtcDateTime
-                var orchestrationStart = context.History.First(
-                    e => e.EventType == HistoryEventType.OrchestratorStarted);
-                context.CurrentUtcDateTime = orchestrationStart.Timestamp.ToUniversalTime();
+            // Marks the first OrchestratorStarted event as processed
+            orchestrationStart.IsProcessed = true;
 
-                // Marks the first OrchestratorStarted event as processed
-                orchestrationStart.IsProcessed = true;
-
-                var asyncResult = pwsh.BeginInvoke(outputBuffer);
+            // Finish initializing the Function invocation
+            powerShellServices.AddParameter(orchestrationBindingInfo.ParameterName, context);
+            powerShellServices.TracePipelineObject();
 
-                var (shouldStop, actions) =
-                    orchestrationBindingInfo.Context.OrchestrationActionCollector.WaitForActions(asyncResult.AsyncWaitHandle);
+            var asyncResult = powerShellServices.BeginInvoke(outputBuffer);
 
-                if (shouldStop)
+            var (shouldStop, actions) =
+                orchestrationBindingInfo.Context.OrchestrationActionCollector.WaitForActions(asyncResult.AsyncWaitHandle);
+
+            if (shouldStop)
+            {
+                // The orchestration function should be stopped and restarted
+                powerShellServices.StopInvoke();
+                return CreateOrchestrationResult(isDone: false, actions, output: null, context.CustomStatus);
+            }
+            else
+            {
+                try
                 {
-                    // The orchestration function should be stopped and restarted
-                    pwsh.StopInvoke();
-                    return CreateOrchestrationResult(isDone: false, actions, output: null, context.CustomStatus);
+                    // The orchestration function completed
+                    powerShellServices.EndInvoke(asyncResult);
+                    var result = CreateReturnValueFromFunctionOutput(outputBuffer);
+                    return CreateOrchestrationResult(isDone: true, actions, output: result, context.CustomStatus);
                 }
-                else
+                catch (Exception e)
                 {
-                    try
-                    {
-                        // The orchestration function completed
-                        pwsh.EndInvoke(asyncResult);
-                        var result = FunctionReturnValueBuilder.CreateReturnValueFromFunctionOutput(outputBuffer);
-                        return CreateOrchestrationResult(isDone: true, actions, output: result, context.CustomStatus);
-                    }
-                    catch (Exception e)
-                    {
-                        // The orchestrator code has thrown an unhandled exception:
-                        // this should be treated as an entire orchestration failure
-                        throw new OrchestrationFailureException(actions, context.CustomStatus, e);
-                    }
+                    // The orchestrator code has thrown an unhandled exception:
+                    // this should be treated as an entire orchestration failure
+                    throw new OrchestrationFailureException(actions, context.CustomStatus, e);
                 }
             }
-            finally
+        }
+
+        public static object CreateReturnValueFromFunctionOutput(IList<object> pipelineItems)
+        {
+            if (pipelineItems == null || pipelineItems.Count <= 0)
             {
-                pwsh.ClearStreamsAndCommands();
+                return null;
             }
+
+            return pipelineItems.Count == 1 ? pipelineItems[0] : pipelineItems.ToArray();
         }
 
         private static Hashtable CreateOrchestrationResult(
@@ -74,5 +113,10 @@ private static Hashtable CreateOrchestrationResult(
             var orchestrationMessage = new OrchestrationMessage(isDone, actions, output, customStatus);
             return new Hashtable { { AzFunctionInfo.DollarReturn, orchestrationMessage } };
         }
+
+        public void SetExternalInvoker(IExternalOrchestrationInvoker externalInvoker)
+        {
+            this.externalInvoker = externalInvoker;
+        }
     }
 }