Bring entity logic into DurableTask.Core (first milestone) #887

sebastianburckhardt · 2023-04-13T21:05:41Z

As discussed in #862 (comment), this PR is a reduced form of the original PR #862.

It contains the implementaton of entity mechanics, compatible with existing DF SDK, but not the user-facing entity SDK for DTFx.

…ut without a user-facing entity SDK for DTFx

cgillum · 2023-04-14T16:04:53Z

Looks like some tests are failing. A couple of them are in DurableTask.Core.Tests.CustomExceptionsTests and appear to require some additional code changes (or test changes).

cgillum

I finished my first round of review of this code, covering all files. There was a lot of skimming involved, however, since it's still pretty huge. I focused mostly on style, structure, public surface area, and other misc. things like logging.

src/DurableTask.Core/Entities/ClientEntityContext.cs

src/DurableTask.Core/Entities/EntityBackendInformation.cs

src/DurableTask.Core/Entities/IEntityExecutor.cs

cgillum · 2023-04-14T16:21:09Z

src/DurableTask.Core/Entities/OperationFormat/OperationAction.cs

+#nullable enable
+namespace DurableTask.Core.Entities.OperationFormat
+{
+    using Newtonsoft.Json;


Is it possible for us to use System.Runtime.Serialization instead of Newtonsoft.Json in these files? Ideally DT.Core standardizes on just the former for defining data contracts. This PR generally seems to use a mix of both and I just want to confirm whether it's intentional.

Since I don't have a very good idea about what serializers are used and why in all the different environments, I was just following the identical approach as what is already being used in OrchestratorAction.cs, since that appears to function satisfactorily.

IMO those two should always be kept consistent. If we want to revise this, we should revise both. And probably not in this PR since it is already so big.

src/DurableTask.Core/TaskHubWorker.cs

src/DurableTask.Core/TaskOrchestrationContext.cs

cgillum · 2023-04-14T16:50:35Z

src/DurableTask.Core/TaskEntityDispatcher.cs

+                {
+                    // TODO : mark an orchestration as faulted if there is data corruption
+                    this.logHelper.DroppingOrchestrationWorkItem(workItem, "Received work-item for an invalid orchestration");
+                    TraceHelper.TraceSession(


Is this just a copy/paste of the TaskOrchestrationDispatcher code? I wouldn't expect that we'd want to use these old TraceHelper classes. I'd rather we not carry them forward in new code.

Is this just a copy/paste

Yes.

I'd rather we not carry them forward in new code

I will remove them all from the TaskEntityDispatcher.

FYI, can't remove TraceHelper.TraceExceptionInstance since it throws an exception. Will keep that for consistency with the other two dispatchers.

Looking at TaskOrchestrationDispatcher, I can see that there are many calls to TraceHelper (the old way of doing tracing) that do not have a corresponding call to LogHelper (the new way of doing tracing). I am not sure if this was

a conscious choice (as in: we really don't want to do so much logging anymore) or

a question of priorities (as in: I don't have time to port all this tracing code right now).

If the reason is 1. then we are done here. I suspect the reason may have been 2., however.

Given that the code paths are almost exactly the same for TaskOrchestrationDispatcher and TaskEntityDispatcher, it really does not make any sense to write LogHelper methods just for TaskEntityDispatcher. The right design would be to call the same methods from both dispatchers (along with an indication of which dispatcher is calling them).

The question remains whether it makes sense to tack the "port tracehelper to loghelper" work item onto this PR. What do you think?

I can see that there are many calls to TraceHelper (the old way of doing tracing) that do not have a corresponding call to LogHelper (the new way of doing tracing).

I recall when doing this work that I intentionally didn't add logs for certain TraceHelper events because I thought they were too noisy or redundant - so (1) is most likely in the cases you looked at. That said, it's not a big deal if we want to just keep the existing ones in the code - however, we don't generally consider them when doing Kusto queries for production issues.

…n TaskHubWorker, fix some comments

cgillum

A few more small things

cgillum · 2023-04-19T18:45:35Z

src/DurableTask.Core/Entities/EntityExecutionOptions.cs

+//  See the License for the specific language governing permissions and
+//  limitations under the License.
+//  ----------------------------------------------------------------------------------
+namespace DurableTask.Core.Entities


Should we add #nullable enable on these new classes?

I added it to almost all new classes. There are a few exceptions; some classes were ported from previously existing code and would require a lot of annotations or maybe changes, it did not seem worth the effort (and risk) to extensively modify them.

cgillum · 2023-04-19T18:47:44Z

src/DurableTask.Core/Entities/OperationFormat/StartNewOrchestrationOperationAction.cs

+    using System.Collections.Generic;
+
+    /// <summary>
+    /// Orchestrator action for creating sub-orchestrations.


I can see that from the class name, but not from this summary description. Should it instead say, "Entity action for creating sub-orchestrations"?

cgillum · 2023-04-19T18:52:10Z

src/DurableTask.Core/TaskHubWorker.cs

@@ -85,6 +98,7 @@ public TaskHubWorker(IOrchestrationService orchestrationService, ILoggerFactory
        /// <param name="orchestrationService">Reference the orchestration service implementation</param>
        /// <param name="orchestrationObjectManager">NameVersionObjectManager for Orchestrations</param>
        /// <param name="activityObjectManager">NameVersionObjectManager for Activities</param>
+        /// <remarks></remarks>


Can we remove this empty comment block?

cgillum · 2023-04-19T18:53:02Z

src/DurableTask.Core/TaskHubWorker.cs

+        /// <returns></returns>
+        public TaskHubWorker AddTaskEntities(params Type[] taskEntityTypes)
+        {
+            if (this.SupportsEntities)


Suggested change

if (this.SupportsEntities)

if (!this.SupportsEntities)

wow, not sure how this escaped testing. Must have not run the tests on latest changes yet.

cgillum · 2023-04-19T18:55:48Z

src/DurableTask.Core/TaskEntityDispatcher.cs

+                        isExtendedSession = this.concurrentSessionLock.Acquire();
+                        this.concurrentSessionLock.Release();
+                        workItem.IsExtendedSession = isExtendedSession;
+                    });


Let's remove all references to CorrelationTraceClient. This is a preview feature that we're planning to remove anyways so I'd rather not add new references to it.

davidmrdavid

Finally got around making a full pass (some skimming was necessary). Some questions and comments

davidmrdavid · 2023-04-19T17:11:47Z

src/DurableTask.Core/TaskOrchestrationExecutor.cs

+        /// Initializes a new instance of the <see cref="TaskOrchestrationExecutor"/> class.
+        /// This overload is needed only to avoid breaking changes because this is a public constructor.
+        /// </summary>
+        /// <param name="orchestrationRuntimeState"></param>
+        /// <param name="taskOrchestration"></param>
+        /// <param name="eventBehaviourForContinueAsNew"></param>
+        /// <param name="errorPropagationMode"></param>
+        public TaskOrchestrationExecutor(
+            OrchestrationRuntimeState orchestrationRuntimeState,
+            TaskOrchestration taskOrchestration,
+            BehaviorOnContinueAsNew eventBehaviourForContinueAsNew,
+            ErrorPropagationMode errorPropagationMode = ErrorPropagationMode.SerializeExceptions)
+            : this(orchestrationRuntimeState, taskOrchestration, eventBehaviourForContinueAsNew, new EntityBackendProperties(), errorPropagationMode)
+        {
+        }


Just to confirm this corresponds to the existing constructor, which we're re-creating as an overload now that we've added a new parameter (entityBackendProperties) to the constructor we used to have, right?

Also, I noticed the new EntityBackendProperties parameter in the old constructor is nullable (i.e has a ?). Given this, why do we need to pass a newly constructed EntityBackendProperties object to it instead of null?

I think that is a leftover from an earlier version that was always passing a non-null object. I agree that this should be passing null, which means anyone who is using the legacy constructor runs without using the new entity dispatcher.

davidmrdavid · 2023-04-19T17:16:04Z

src/DurableTask.Core/TaskOrchestrationDispatcher.cs

                    renewCancellationTokenSource.Token);
            }

            try
            {
                // Assumes that: if the batch contains a new "ExecutionStarted" event, it is the first message in the batch.
-                if (!this.ReconcileMessagesWithState(workItem))
+                if (!ReconcileMessagesWithState(workItem, "TaskOrchestrationDispatcher", logHelper))


any reason not to do this?

Suggested change

if (!ReconcileMessagesWithState(workItem, "TaskOrchestrationDispatcher", logHelper))

if (!ReconcileMessagesWithState(workItem, nameof(TaskOrchestrationDispatcher), logHelper))

davidmrdavid · 2023-04-19T17:19:30Z

src/DurableTask.Core/TaskOrchestrationDispatcher.cs

+                // we call the entity interface to make sure we are receiving only true orchestrations here
+                return this.entityOrchestrationService.LockNextOrchestrationWorkItemAsync(receiveTimeout, cancellationToken);
+            }
+            else
+            {
+                return this.orchestrationService.LockNextTaskOrchestrationWorkItemAsync(receiveTimeout, cancellationToken);


When you say "to make sure we are receiving only true orchestrations here", "here" actually refers to the else-case, right? I found this a bit confusing.

Updated the comment.

davidmrdavid · 2023-04-19T17:21:12Z

src/DurableTask.Core/OrchestrationContext.cs

+        /// <summary>
+        /// Information about backend entity support, or null if the configured backend does not support entities.
+        /// </summary>
+        internal EntityBackendProperties EntityBackendProperties { get; set; }


If this might be null, shouldn't it be EntityBackendProperties?

This class does not have #nullable enable.
(It is a pre-existing class so I am not changing that)

davidmrdavid · 2023-04-19T17:23:27Z

src/DurableTask.Core/TaskHubWorker.cs

@@ -85,6 +98,7 @@ public TaskHubWorker(IOrchestrationService orchestrationService, ILoggerFactory
        /// <param name="orchestrationService">Reference the orchestration service implementation</param>
        /// <param name="orchestrationObjectManager">NameVersionObjectManager for Orchestrations</param>
        /// <param name="activityObjectManager">NameVersionObjectManager for Activities</param>
+        /// <remarks></remarks>


Do we need this if there's no remarks?

Suggested change

/// <remarks></remarks>

davidmrdavid · 2023-04-19T18:17:31Z

src/DurableTask.Core/TaskEntityDispatcher.cs

+                            processCount++;
+                        }
+
+                        // Fetches beyond the first require getting an extended session lock, used to prevent starvation.


not sure I understand this comment. Can we rephrase this? What is "the first require"?

The logic and wording is slightly weird, but this was just copy-pasted from existing code. I am not actually sure why this would be called without new messages, then there really is no "first fetch".

davidmrdavid · 2023-04-19T18:33:45Z

src/DurableTask.Core/Entities/StateFormat/MessageSorter.cs

+
+            DateTime timestamp = now;
+
+            if (SendHorizon + reorderWindow + MinIntervalBetweenCollections < now)


I know you've walked me through this in the past, but I still get a bit confused by the MinIntervalBetweenCollections term in this if statement. The expression makes perfect sense to me if it were just SendHorizon + reorderWindow < now, and I get quickly confused when I try to figure out how the interval bit affects this calculation.

Can we add a clarifying comment in here?

I wrote a longer comment.

davidmrdavid · 2023-04-19T18:55:03Z

src/DurableTask.Core/Entities/StateFormat/MessageSorter.cs

+                // deliver any messages that were held in the receive buffers
+                // but are now past the reorder window
+
+                List<string> emptyReceiveBuffers = new List<string>();


nit - I think a better name would be "buffersToRemove".
The name emptyReceiveBuffers makes me think they were always empty, but in fact they become cleared in this method.

davidmrdavid · 2023-04-19T18:57:02Z

src/DurableTask.Core/Entities/StateFormat/MessageSorter.cs

+                        if (kvp.Value.Last < ReceiveHorizon)
+                        {
+                            kvp.Value.Last = DateTime.MinValue;
+                        }


just to add clarity, assuming this is correct:

Suggested change

if (kvp.Value.Last < ReceiveHorizon)

{

kvp.Value.Last = DateTime.MinValue;

}

// Check if buffered messages are ready to be delivered

if (kvp.Value.Last < ReceiveHorizon)

{

// flag as ready to be delivered

kvp.Value.Last = DateTime.MinValue;

}

It's hard to write comments about this. The algorithm is complicated and I don't fully remember myself. We would need a TLA+ model to really document how this thing works.

davidmrdavid · 2023-04-19T18:58:08Z

src/DurableTask.Core/Entities/StateFormat/MessageSorter.cs

+                        if (kvp.Value.Last == DateTime.MinValue
+                            && (kvp.Value.Buffered == null || kvp.Value.Buffered.Count == 0))
+                        {
+                            emptyReceiveBuffers.Add(kvp.Key);
+                        }


nit - to add more clarity, assuming my understanding is correct:

Suggested change

if (kvp.Value.Last == DateTime.MinValue

&& (kvp.Value.Buffered == null || kvp.Value.Buffered.Count == 0))

{

emptyReceiveBuffers.Add(kvp.Key);

}

// determine if buffer is empty, so it can be removed

if (kvp.Value.Last == DateTime.MinValue

&& (kvp.Value.Buffered == null || kvp.Value.Buffered.Count == 0))

{

emptyReceiveBuffers.Add(kvp.Key);

}

I added some comment.

jviau

I noticed you had some logic about processing entities together or separately. This is great and I think that will help the dotnet isolated implementation.

For dotnet isolated it will help for us to process them together, so that we can dispatch an entity using the existing gRPC protocol to the worker. Then on the worker side after deserialization we can differentiate between entity and orchestration and invoke them differently. For this to work, it will be helpful for us to have access to the following logic:

Something that can differentiate between orchestration and entity (fine if this is copy & pasted code, but well defined rules for us to follow would be great)
A TaskEntityExecutor, which takes in the same arguments as TaskOrchestrationExecutor, but a TaskEntity instead of TaskOrchestration. We will handle constructing the TaskEntity object and invoking it.

jviau · 2023-05-31T17:13:39Z

src/DurableTask.Core/Common/Fnv1aHashHelper.cs

@@ -22,32 +21,61 @@ namespace DurableTask.AzureStorage
    /// See https://en.wikipedia.org/wiki/Fowler%E2%80%93Noll%E2%80%93Vo_hash_function.
    /// Tested with production data and random guids. The result was good distribution.
    /// </remarks>
-    static class Fnv1aHashHelper
+    public static class Fnv1aHashHelper


I would prefer not to add something like this to the public API space. Can we make a copy? Or link it in to each csproj explicitly?

Made a copy for DurableTask.AzureStorage

jviau · 2023-05-31T17:14:10Z

src/DurableTask.Core/Entities/ClientEntityHelpers.cs

+    /// <summary>
+    /// Utility functions for clients that interact with entities, either by sending events or by accessing the entity state directly in storage
+    /// </summary>
+    public static class ClientEntityHelpers


Are customers expected to use this directly? Does this need to be public?

It is used by the SDKs that implement the entity API. Those are not the customers directly, all such SDKs are meant to be written by our team. So this class, though technically public, should be considered internal from a support perspective. We are not officially supporting scenarios where anyone outside of our team is using this class (they are not supposed to).

For example, this is used by the implementation of AzureStorageDurabilityProvider in webjobs-extensions-durabletask. And it would likely be what you want to use when implementing the client in the isolated SDK.

jviau · 2023-05-31T17:15:12Z

src/DurableTask.Core/Entities/ClientEntityHelpers.cs

+        /// <param name="input">The serialized input for the operation.</param>
+        /// <param name="scheduledTimeUtc">The time to schedule this signal, or null if not a scheduled signal</param>
+        /// <returns>The event to send.</returns>
+        public static EventToSend EmitOperationSignal(OrchestrationInstance targetInstance, Guid requestId, string operationName, string input, (DateTime original, DateTime capped)? scheduledTimeUtc)


nit: upper-case value tuple names

Suggested change

public static EventToSend EmitOperationSignal(OrchestrationInstance targetInstance, Guid requestId, string operationName, string input, (DateTime original, DateTime capped)? scheduledTimeUtc)

public static EventToSend EmitOperationSignal(OrchestrationInstance targetInstance, Guid requestId, string operationName, string input, (DateTime Original, DateTime Capped)? scheduledTimeUtc)

Also, use DateTimeOffset in favor of DateTime - it is a better structure overall (it is more robust, includes explicit timezone value directly into it).

updated the tuple names. Not changing DateTimeOffset for now, I think it is better to stay consistent with the rest of the code which is using DateTime. All of our DateTime are always Utc anyway.

jviau · 2023-05-31T17:16:48Z

src/DurableTask.Core/Entities/EntityBackendProperties.cs

+        /// <summary>
+        /// Computes a cap on the scheduled time of an entity signal, based on the maximum signal delay time
+        /// </summary>
+        /// <param name="nowUtc"></param>


nit: fill in comments please

jviau · 2023-05-31T17:18:28Z

src/DurableTask.Core/Entities/EntityId.cs

+        /// The name for this class of entities.
+        /// </summary>
+        [DataMember(Name = "name", IsRequired = true)]
+        public readonly string Name;


nit: use properties not fields for anything beyond private:

Suggested change

public readonly string Name;

public string Name { get; }

ok, trying this out for Name and Key fields.

jviau · 2023-05-31T17:25:47Z

src/DurableTask.Core/Entities/EntityId.cs

+    /// A unique identifier for an entity, consisting of entity name and entity key.
+    /// </summary>
+    [DataContract]
+    public readonly struct EntityId : IEquatable<EntityId>, IComparable


Think it is worth adding what we need to access record structs in this project? It would simplify a lot of your logic, as it comes with equality, hash code, all that:

public record struct EntityId(string Name, string Key) { // override ToString, add FromString, and other methods as necessary. }

Given that it is already done I see little motivation to replace it with a different way to do the same thing. Will keep in mind for future code though.

jviau · 2023-05-31T17:32:16Z

src/DurableTask.Core/Entities/OperationFormat/OperationActionConverter.cs

+                    case OperationActionType.StartNewOrchestration:
+                        return new StartNewOrchestrationOperationAction();
+                    default:
+                        throw new NotSupportedException("Unrecognized action type.");


This sounds like it would be a very high volume log. Would it offer enough value to warrant it?

jviau · 2023-05-31T17:36:11Z

src/DurableTask.Core/Entities/OrchestrationEntityContext.cs

+        {
+            if (this.IsInsideCriticalSection)
+            {
+                foreach(var e in this.availableLocks!)


Suggested change

foreach(var e in this.availableLocks!)

foreach (var e in this.availableLocks!)

jviau · 2023-05-31T17:53:36Z

src/DurableTask.Core/TaskEntityDispatcher.cs

+            await this.dispatcher.StopAsync(forced);
+        }
+
+


nit: remove newline

Suggested change

jviau · 2023-05-31T17:56:56Z

src/DurableTask.Core/TaskEntityDispatcher.cs

+        readonly ErrorPropagationMode errorPropagationMode;
+        readonly TaskOrchestrationDispatcher.NonBlockingCountdownLock concurrentSessionLock;
+
+


Suggested change

sebastianburckhardt · 2023-06-27T23:20:32Z

For dotnet isolated it will help for us to process them together, so that we can dispatch an entity using the existing gRPC protocol to the worker. Then on the worker side after deserialization we can differentiate between entity and orchestration and invoke them differently.

I think it would be cleaner to update the gRPC protocol so it supports entity work items directly. Since we are revising this anyway, I see little benefit to treating entity work items and orchestration work items the same way. We did this in the previous implementation and it just makes things more complicated than necessary, it is a lesson we have learnt. Orchestrations and entities execute very differently. I would like to represent entity work items as batches of operations, there is no history and no replay involved.

src/DurableTask.Core/FailureDetails.cs

src/DurableTask.Core/TaskOrchestrationExecutor.cs

* Bring entity logic into DurableTask.Core (first milestone) (#887) * implementaton of entity mechanics, compatible with existing DF SDK, but without a user-facing entity SDK for DTFx * address PR feedback. * fix usings and namespaces * address PR feedback * address PR feedback (remove NameObjectManager), fix breaking change in TaskHubWorker, fix some comments * address PR feedback (fix CustomExceptionsTest, remove public property) * add #nullable enable to most new classes * address PR feedback * try to fix compiler errors * add a configuration setting that disables separate dispatch by default * address PR feedback * address PR feedback * fix semantic merge conflict. * Revise entity state and status format and access (#955) * update scheduler state and entity status format and helpers * fix mess-up caused by merge conflict * Revise entity message format and external access (#956) * revise how event messages are represented and used * fix merge anomaly. * make current critical section id publicly visible (#958) * remove orchestration tags from entity action (#952) * Rename OperationBatchRequest and OperationBatchResponse (#953) * rename OperationBatch to EntityBatch * fix accidentally commited change from another PR * Revise how entity batches are executed and handle failures (#954) * revise task entity definition * commit change that had been accidentally committed to a different PR. * Apply suggestions from code review Co-authored-by: David Justo <david.justo.1996@gmail.com> * Apply suggestions from code review Co-authored-by: Jacob Viau <javia@microsoft.com> --------- Co-authored-by: David Justo <david.justo.1996@gmail.com> Co-authored-by: Jacob Viau <javia@microsoft.com> * revise operation result encoding and add more comments. (#965) * revise entity backend properties and implement entity backend queries (#957) * revise entity backend properties and implement entity backend queries. * Minor revisions to querries and properties, and improved comments. * fix validation of which LockNext methods are being called. * improve comments * fix useage of IEntityOrchestrationService. * revise how to exclude entity results from queries. * address PR feedback * Update versions for ADO feed (#973) * Add no-warn for NU5104 (#974) * revise propagation path for entity parameters (#971) * fix propagation path for entity parameters that need to reach the orchestration executor. * address PR feedback. * Revise entity queries (#981) * rename includeDeletedEntities to includeStatelessEntities and add comment explaining the meaning * add backlogQueueSize and lockedBy to entity metadata * fix bugs in tracking store implementation (#979) * add scheduled start time parameter to the start-new-orchestration operation action. (#980) * Revise serialization of entitymessages (#972) * revise how entity messages are serialized when sent by orchestrators. * address PR feedback (use RawInput) * Rename includeStateless to includeTransient in entity queries (#985) * rename includeStateless to includeTransient * rename variable also * Rev to entities-preview.2 (#986) * fix null reference exception when running on older backends (#989) * Prepare for public preview (#994) --------- Co-authored-by: David Justo <david.justo.1996@gmail.com> Co-authored-by: Jacob Viau <javia@microsoft.com>

implementaton of entity mechanics, compatible with existing DF SDK, b…

258d464

…ut without a user-facing entity SDK for DTFx

sebastianburckhardt mentioned this pull request Apr 13, 2023

Bring entity logic into DurableTask.Core #862

Closed

cgillum reviewed Apr 14, 2023

View reviewed changes

sebastianburckhardt added 5 commits April 14, 2023 10:24

address PR feedback.

1e568b8

fix usings and namespaces

61c6380

address PR feedback

32edd21

address PR feedback (remove NameObjectManager), fix breaking change i…

96511b3

…n TaskHubWorker, fix some comments

address PR feedback (fix CustomExceptionsTest, remove public property)

02ab50f

cgillum reviewed Apr 19, 2023

View reviewed changes

davidmrdavid reviewed Apr 19, 2023

View reviewed changes

sebastianburckhardt added 4 commits May 24, 2023 10:40

add #nullable enable to most new classes

22c95c5

address PR feedback

0032faa

try to fix compiler errors

175af9b

add a configuration setting that disables separate dispatch by default

ab4487f

jviau reviewed May 31, 2023

View reviewed changes

address PR feedback

78dca7a

jviau requested changes Jul 21, 2023

View reviewed changes

src/DurableTask.Core/FailureDetails.cs Outdated Show resolved Hide resolved

src/DurableTask.Core/TaskOrchestrationExecutor.cs Show resolved Hide resolved

sebastianburckhardt added 2 commits August 7, 2023 08:56

address PR feedback

a14401d

Merge branch 'main' into draft-core-entities-minimum

ede9644

sebastianburckhardt requested a review from jviau August 8, 2023 18:35

sebastianburckhardt changed the base branch from main to feature/core-entities August 28, 2023 22:55

jviau approved these changes Aug 28, 2023

View reviewed changes

sebastianburckhardt merged commit adcaf61 into feature/core-entities Aug 29, 2023

sebastianburckhardt deleted the draft-core-entities-minimum branch August 29, 2023 16:23

	if (!ReconcileMessagesWithState(workItem, "TaskOrchestrationDispatcher", logHelper))
	if (!ReconcileMessagesWithState(workItem, nameof(TaskOrchestrationDispatcher), logHelper))


		DateTime timestamp = now;

		if (SendHorizon + reorderWindow + MinIntervalBetweenCollections < now)

	public static EventToSend EmitOperationSignal(OrchestrationInstance targetInstance, Guid requestId, string operationName, string input, (DateTime original, DateTime capped)? scheduledTimeUtc)
	public static EventToSend EmitOperationSignal(OrchestrationInstance targetInstance, Guid requestId, string operationName, string input, (DateTime Original, DateTime Capped)? scheduledTimeUtc)

	foreach(var e in this.availableLocks!)
	foreach (var e in this.availableLocks!)

		readonly ErrorPropagationMode errorPropagationMode;
		readonly TaskOrchestrationDispatcher.NonBlockingCountdownLock concurrentSessionLock;

Bring entity logic into DurableTask.Core (first milestone) #887

Bring entity logic into DurableTask.Core (first milestone) #887

Conversation

sebastianburckhardt commented Apr 13, 2023

cgillum commented Apr 14, 2023

cgillum left a comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

cgillum left a comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

davidmrdavid left a comment • edited Loading

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

jviau left a comment • edited Loading

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

jviau May 31, 2023 • edited Loading

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

sebastianburckhardt commented Jun 27, 2023

davidmrdavid left a comment •

edited

Loading

jviau left a comment •

edited

Loading

jviau May 31, 2023 •

edited

Loading