Enable suspend-resume of orchestrators.

src/DurableTask.AzureStorage/AzureStorageOrchestrationService.cs

@@ -937,7 +937,8 @@ bool IsExecutableInstance(OrchestrationRuntimeState runtimeState, IList<TaskMess
 
             if (runtimeState.ExecutionStartedEvent != null &&
                 runtimeState.OrchestrationStatus != OrchestrationStatus.Running &&
-                runtimeState.OrchestrationStatus != OrchestrationStatus.Pending)
+                runtimeState.OrchestrationStatus != OrchestrationStatus.Pending &&
+                runtimeState.OrchestrationStatus != OrchestrationStatus.Suspended)
             {
                 message = $"Instance is {runtimeState.OrchestrationStatus}";
                 return false;
@@ -1847,6 +1848,7 @@ public async Task<OrchestrationState> WaitForOrchestrationAsync(
                 OrchestrationState state = await this.GetOrchestrationStateAsync(instanceId, executionId);
                 if (state == null ||
                     state.OrchestrationStatus == OrchestrationStatus.Running ||
+                    state.OrchestrationStatus == OrchestrationStatus.Suspended ||
                     state.OrchestrationStatus == OrchestrationStatus.Pending ||
                     state.OrchestrationStatus == OrchestrationStatus.ContinuedAsNew)
                 {

src/DurableTask.AzureStorage/DurableTask.AzureStorage.csproj

@@ -20,8 +20,8 @@
   <!-- Version Info -->
   <PropertyGroup>
     <MajorVersion>1</MajorVersion>
-    <MinorVersion>12</MinorVersion>
-    <PatchVersion>1</PatchVersion>
+    <MinorVersion>13</MinorVersion>
+    <PatchVersion>0</PatchVersion>
 
     <Version>$(MajorVersion).$(MinorVersion).$(PatchVersion)</Version>
     <FileVersion>$(Version).0</FileVersion>

src/DurableTask.AzureStorage/Tracking/AzureTableTrackingStore.cs

@@ -993,6 +993,28 @@ public override async Task<string> UpdateStateAsync(
                             instancePropertyName: OutputProperty,
                             data: executionTerminatedEvent.Input);
                         break;
+                    case EventType.ExecutionSuspended:
+                        runtimeStatus = OrchestrationStatus.Suspended;
+                        ExecutionSuspendedEvent executionSuspendedEvent = (ExecutionSuspendedEvent)historyEvent;
+                        instanceEntity.Properties["RuntimeStatus"] = new EntityProperty(OrchestrationStatus.Suspended.ToString());
+                        this.SetInstancesTablePropertyFromHistoryProperty(
+                            historyEntity,
+                            instanceEntity,
+                            historyPropertyName: nameof(executionSuspendedEvent.Reason),
+                            instancePropertyName: OutputProperty,
+                            data: executionSuspendedEvent.Reason);
+                        break;
+                    case EventType.ExecutionResumed:
+                        runtimeStatus = OrchestrationStatus.Running;
+                        ExecutionResumedEvent executionResumedEvent = (ExecutionResumedEvent)historyEvent;
+                        instanceEntity.Properties["RuntimeStatus"] = new EntityProperty(OrchestrationStatus.Running.ToString());
+                        this.SetInstancesTablePropertyFromHistoryProperty(
+                            historyEntity,
+                            instanceEntity,
+                            historyPropertyName: nameof(executionResumedEvent.Reason),
+                            instancePropertyName: OutputProperty,
+                            data: executionResumedEvent.Reason);
+                        break;
                     case EventType.ContinueAsNew:
                         runtimeStatus = OrchestrationStatus.ContinuedAsNew;
                         ExecutionCompletedEvent executionCompletedEvent = (ExecutionCompletedEvent)historyEvent;

src/DurableTask.Core/DurableTask.Core.csproj

@@ -17,7 +17,7 @@
   <!-- Version Info -->
   <PropertyGroup>
     <MajorVersion>2</MajorVersion>
-    <MinorVersion>10</MinorVersion>
+    <MinorVersion>11</MinorVersion>
     <PatchVersion>0</PatchVersion>
 
     <Version>$(MajorVersion).$(MinorVersion).$(PatchVersion)</Version>

src/DurableTask.Core/History/EventType.cs

@@ -11,6 +11,9 @@
 //  limitations under the License.
 //  ----------------------------------------------------------------------------------
 
+
+// NOTE: Changing the order of variables may cause bugs in OOProc SDKs. When introducing
+//       new EventTypes, append them at the end.
 namespace DurableTask.Core.History
 {
     /// <summary>
@@ -112,5 +115,15 @@ public enum EventType
         /// Orchestration state history event
         /// </summary>
         HistoryState,
+
+        /// <summary>
+        /// Orchestration was suspended event
+        /// </summary>
+        ExecutionSuspended,
+
+        /// <summary>
+        /// Orchestration was resumed event
+        /// </summary>
+        ExecutionResumed,
     }
 }

src/DurableTask.Core/History/ExecutionResumedEvent.cs

@@ -0,0 +1,46 @@
+//  ----------------------------------------------------------------------------------
+//  Copyright Microsoft Corporation
+//  Licensed under the Apache License, Version 2.0 (the "License");
+//  you may not use this file except in compliance with the License.
+//  You may obtain a copy of the License at
+//  http://www.apache.org/licenses/LICENSE-2.0
+//  Unless required by applicable law or agreed to in writing, software
+//  distributed under the License is distributed on an "AS IS" BASIS,
+//  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//  See the License for the specific language governing permissions and
+//  limitations under the License.
+//  ----------------------------------------------------------------------------------
+
+namespace DurableTask.Core.History
+{
+    using System.Runtime.Serialization;
+
+    /// <summary>
+    /// A history event for orchestration resuming
+    /// </summary>
+    [DataContract]
+    public class ExecutionResumedEvent : HistoryEvent
+    {
+        /// <summary>
+        /// Creates a new ExecutionResumedEvent with the supplied params
+        /// </summary>
+        /// <param name="eventId">The event id of the history event</param>
+        /// <param name="reason">The serialized reason of the resuming event</param>
+        public ExecutionResumedEvent(int eventId, string reason)
+            : base(eventId)
+        {
+            Reason = reason;
+        }
+
+        /// <summary>
+        /// Gets the event type
+        /// </summary>
+        public override EventType EventType => EventType.ExecutionResumed;
+
+        /// <summary>
+        /// Gets or sets the reason for the resuming event
+        /// </summary>
+        [DataMember]
+        public string Reason { get; set; }
+    }
+}

src/DurableTask.Core/History/ExecutionSuspendedEvent.cs

@@ -0,0 +1,46 @@
+//  ----------------------------------------------------------------------------------
+//  Copyright Microsoft Corporation
+//  Licensed under the Apache License, Version 2.0 (the "License");
+//  you may not use this file except in compliance with the License.
+//  You may obtain a copy of the License at
+//  http://www.apache.org/licenses/LICENSE-2.0
+//  Unless required by applicable law or agreed to in writing, software
+//  distributed under the License is distributed on an "AS IS" BASIS,
+//  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//  See the License for the specific language governing permissions and
+//  limitations under the License.
+//  ----------------------------------------------------------------------------------
+
+namespace DurableTask.Core.History
+{
+    using System.Runtime.Serialization;
+
+    /// <summary>
+    /// A history event for orchestration suspension.
+    /// </summary>
+    [DataContract]
+    public class ExecutionSuspendedEvent : HistoryEvent
+    {
+        /// <summary>
+        /// Creates a new ExecutionSuspendedEvent with the supplied params
+        /// </summary>
+        /// <param name="eventId">The event id of the history event</param>
+        /// <param name="reason">The serialized input of the suspension event</param>
+        public ExecutionSuspendedEvent(int eventId, string reason)
+            : base(eventId)
+        {
+            Reason = reason;
+        }
+
+        /// <summary>
+        /// Gets the event type
+        /// </summary>
+        public override EventType EventType => EventType.ExecutionSuspended;
+
+        /// <summary>
+        /// Gets or sets the serialized input for the the suspension event
+        /// </summary>
+        [DataMember]
+        public string Reason { get; set; }
+    }
+}

src/DurableTask.Core/Logging/EventIds.cs

@@ -56,5 +56,8 @@ static class EventIds
         public const int RenewActivityMessageStarting = 65;
         public const int RenewActivityMessageCompleted = 66;
         public const int RenewActivityMessageFailed = 67;
+
+        public const int SuspendingInstance = 68;
+        public const int ResumingInstance = 69;
     }
 }

src/DurableTask.Core/Logging/LogEvents.cs

@@ -635,6 +635,78 @@ void IEventSourceEvent.WriteEventSource() =>
                     Utils.PackageVersion);
         }
 
+        internal class SuspendingInstance : StructuredLogEvent, IEventSourceEvent
+        {
+            public SuspendingInstance(OrchestrationInstance instance, string reason)
+            {
+                this.InstanceId = instance.InstanceId;
+                this.ExecutionId = instance.ExecutionId;
+                this.Details = reason;
+            }
+
+            [StructuredLogField]
+            public string InstanceId { get; }
+
+            [StructuredLogField]
+            public string ExecutionId { get; }
+
+            [StructuredLogField]
+            public string Details { get; }
+
+            public override EventId EventId => new EventId(
+                EventIds.SuspendingInstance,
+                nameof(EventIds.SuspendingInstance));
+
+            public override LogLevel Level => LogLevel.Information;
+
+            protected override string CreateLogMessage() =>
+                $"Suspending instance '{this.InstanceId}': {this.Details}";
+
+            void IEventSourceEvent.WriteEventSource() =>
+                StructuredEventSource.Log.SuspendingInstance(
+                    this.InstanceId,
+                    this.ExecutionId,
+                    this.Details,
+                    Utils.AppName,
+                    Utils.PackageVersion);
+        }
+
+        internal class ResumingInstance : StructuredLogEvent, IEventSourceEvent
+        {
+            public ResumingInstance(OrchestrationInstance instance, string reason)
+            {
+                this.InstanceId = instance.InstanceId;
+                this.ExecutionId = instance.ExecutionId;
+                this.Details = reason;
+            }
+
+            [StructuredLogField]
+            public string InstanceId { get; }
+
+            [StructuredLogField]
+            public string ExecutionId { get; }
+
+            [StructuredLogField]
+            public string Details { get; }
+
+            public override EventId EventId => new EventId(
+                EventIds.ResumingInstance,
+                nameof(EventIds.ResumingInstance));
+
+            public override LogLevel Level => LogLevel.Information;
+
+            protected override string CreateLogMessage() =>
+                $"Resuming instance '{this.InstanceId}': {this.Details}";
+
+            void IEventSourceEvent.WriteEventSource() =>
+                StructuredEventSource.Log.ResumingInstance(
+                    this.InstanceId,
+                    this.ExecutionId,
+                    this.Details,
+                    Utils.AppName,
+                    Utils.PackageVersion);
+        }
+
         internal class WaitingForInstance : StructuredLogEvent, IEventSourceEvent
         {
             public WaitingForInstance(OrchestrationInstance instance, TimeSpan timeout)

src/DurableTask.Core/Logging/LogHelper.cs

@@ -316,6 +316,32 @@ internal void TerminatingInstance(OrchestrationInstance instance, string reason)
             }
         }
 
+        /// <summary>
+        /// Logs that an instance is being scheduled to be suspended.
+        /// </summary>
+        /// <param name="instance">The instance to be suspended.</param>
+        /// <param name="reason">The user-specified reason for the suspension.</param>
+        internal void SuspendingInstance(OrchestrationInstance instance, string reason)
+        {
+            if (this.IsStructuredLoggingEnabled)
+            {
+                this.WriteStructuredLog(new LogEvents.SuspendingInstance(instance, reason));
+            }
+        }
+
+        /// <summary>
+        /// Logs that an instance is being scheduled to be resumed.
+        /// </summary>
+        /// <param name="instance">The instance to be resumed.</param>
+        /// <param name="reason">The user-specified reason for the resumption.</param>
+        internal void ResumingInstance(OrchestrationInstance instance, string reason)
+        {
+            if (this.IsStructuredLoggingEnabled)
+            {
+                this.WriteStructuredLog(new LogEvents.ResumingInstance(instance, reason));
+            }
+        }
+
         /// <summary>
         /// Logs that the client is waiting for an instance to reach a terminal state.
         /// </summary>

src/DurableTask.Core/Logging/StructuredEventSource.cs

@@ -342,6 +342,46 @@ internal void TerminatingInstance(
             }
         }
 
+        [Event(EventIds.SuspendingInstance, Level = EventLevel.Informational, Version = 1)]
+        internal void SuspendingInstance(
+            string InstanceId,
+            string ExecutionId,
+            string Details,
+            string AppName,
+            string ExtensionVersion)
+        {
+            if (this.IsEnabled(EventLevel.Informational))
+            {
+                this.WriteEvent(
+                    EventIds.SuspendingInstance,
+                    InstanceId,
+                    ExecutionId ?? string.Empty,
+                    Details ?? string.Empty,
+                    AppName,
+                    ExtensionVersion);
+            }
+        }
+
+        [Event(EventIds.ResumingInstance, Level = EventLevel.Informational, Version = 1)]
+        internal void ResumingInstance(
+            string InstanceId,
+            string ExecutionId,
+            string Details,
+            string AppName,
+            string ExtensionVersion)
+        {
+            if (this.IsEnabled(EventLevel.Informational))
+            {
+                this.WriteEvent(
+                    EventIds.ResumingInstance,
+                    InstanceId,
+                    ExecutionId ?? string.Empty,
+                    Details ?? string.Empty,
+                    AppName,
+                    ExtensionVersion);
+            }
+        }
+
         [Event(EventIds.WaitingForInstance, Level = EventLevel.Informational, Version = 1)]
         internal void WaitingForInstance(
             string InstanceId,