one package finalize

Author: YunchuWang

src/Extensions/AzureBlobPayloads/AzureBlobPayloads.csproj

@@ -21,10 +21,10 @@
     <ProjectReference Include="..\..\Worker\Core\Worker.csproj" />
     <ProjectReference Include="..\..\Client\Grpc\Client.Grpc.csproj" />
     <ProjectReference Include="..\..\Worker\Grpc\Worker.Grpc.csproj" />
+    <ProjectReference Include="..\..\Grpc.AzureManagedBackend\Grpc.AzureManagedBackend.csproj" />
   </ItemGroup>
 
   <ItemGroup>
     <SharedSection Include="Core" />
   </ItemGroup>
-
 </Project>

src/Extensions/AzureBlobPayloads/Interceptors/AzureBlobPayloadsManagedBackendInterceptor.cs

@@ -1,19 +1,18 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 
-using Grpc.Core.Interceptors;
-
-using P = Microsoft.DurableTask.Protobuf;
+using P = Microsoft.DurableTask.AzureManagedBackend.Protobuf;
 
 namespace Microsoft.DurableTask;
 
 /// <summary>
 /// gRPC interceptor that externalizes large payloads to an <see cref="IPayloadStore"/> on requests
 /// and resolves known payload tokens on responses for Azure Managed Backend.
 /// </summary>
-public sealed class AzureBlobPayloadsManagedBackendInterceptor(IPayloadStore payloadStore, LargePayloadStorageOptions options) 
+public sealed class AzureBlobPayloadsManagedBackendInterceptor(IPayloadStore payloadStore, LargePayloadStorageOptions options)
     : BasePayloadInterceptor<object, object>(payloadStore, options)
 {
+    /// <inheritdoc/>
     protected override Task ExternalizeRequestPayloadsAsync<TRequest>(TRequest request, CancellationToken cancellation)
     {
         // Azure Managed Backend -> Backend Service
@@ -147,96 +146,112 @@ async Task ExternalizeHistoryEventAsync(P.HistoryEvent e, CancellationToken canc
                 {
                     await this.MaybeExternalizeAsync(v => es.Input = v, es.Input, cancellation);
                 }
+
                 break;
             case P.HistoryEvent.EventTypeOneofCase.ExecutionCompleted:
                 if (e.ExecutionCompleted is { } ec)
                 {
                     await this.MaybeExternalizeAsync(v => ec.Result = v, ec.Result, cancellation);
                 }
+
                 break;
             case P.HistoryEvent.EventTypeOneofCase.EventRaised:
                 if (e.EventRaised is { } er)
                 {
                     await this.MaybeExternalizeAsync(v => er.Input = v, er.Input, cancellation);
                 }
+
                 break;
             case P.HistoryEvent.EventTypeOneofCase.TaskScheduled:
                 if (e.TaskScheduled is { } ts)
                 {
                     await this.MaybeExternalizeAsync(v => ts.Input = v, ts.Input, cancellation);
                 }
+
                 break;
             case P.HistoryEvent.EventTypeOneofCase.TaskCompleted:
                 if (e.TaskCompleted is { } tc)
                 {
                     await this.MaybeExternalizeAsync(v => tc.Result = v, tc.Result, cancellation);
                 }
+
                 break;
             case P.HistoryEvent.EventTypeOneofCase.SubOrchestrationInstanceCreated:
                 if (e.SubOrchestrationInstanceCreated is { } soc)
                 {
                     await this.MaybeExternalizeAsync(v => soc.Input = v, soc.Input, cancellation);
                 }
+
                 break;
             case P.HistoryEvent.EventTypeOneofCase.SubOrchestrationInstanceCompleted:
                 if (e.SubOrchestrationInstanceCompleted is { } sox)
                 {
                     await this.MaybeExternalizeAsync(v => sox.Result = v, sox.Result, cancellation);
                 }
+
                 break;
             case P.HistoryEvent.EventTypeOneofCase.EventSent:
                 if (e.EventSent is { } esent)
                 {
                     await this.MaybeExternalizeAsync(v => esent.Input = v, esent.Input, cancellation);
                 }
+
                 break;
             case P.HistoryEvent.EventTypeOneofCase.GenericEvent:
                 if (e.GenericEvent is { } ge)
                 {
                     await this.MaybeExternalizeAsync(v => ge.Data = v, ge.Data, cancellation);
                 }
+
                 break;
             case P.HistoryEvent.EventTypeOneofCase.ContinueAsNew:
                 if (e.ContinueAsNew is { } can)
                 {
                     await this.MaybeExternalizeAsync(v => can.Input = v, can.Input, cancellation);
                 }
+
                 break;
             case P.HistoryEvent.EventTypeOneofCase.ExecutionTerminated:
                 if (e.ExecutionTerminated is { } et)
                 {
                     await this.MaybeExternalizeAsync(v => et.Input = v, et.Input, cancellation);
                 }
+
                 break;
             case P.HistoryEvent.EventTypeOneofCase.ExecutionSuspended:
                 if (e.ExecutionSuspended is { } esus)
                 {
                     await this.MaybeExternalizeAsync(v => esus.Input = v, esus.Input, cancellation);
                 }
+
                 break;
             case P.HistoryEvent.EventTypeOneofCase.ExecutionResumed:
                 if (e.ExecutionResumed is { } eres)
                 {
                     await this.MaybeExternalizeAsync(v => eres.Input = v, eres.Input, cancellation);
                 }
+
                 break;
             case P.HistoryEvent.EventTypeOneofCase.EntityOperationSignaled:
                 if (e.EntityOperationSignaled is { } eos)
                 {
                     await this.MaybeExternalizeAsync(v => eos.Input = v, eos.Input, cancellation);
                 }
+
                 break;
             case P.HistoryEvent.EventTypeOneofCase.EntityOperationCalled:
                 if (e.EntityOperationCalled is { } eoc)
                 {
                     await this.MaybeExternalizeAsync(v => eoc.Input = v, eoc.Input, cancellation);
                 }
+
                 break;
             case P.HistoryEvent.EventTypeOneofCase.EntityOperationCompleted:
                 if (e.EntityOperationCompleted is { } ecomp)
                 {
                     await this.MaybeExternalizeAsync(v => ecomp.Output = v, ecomp.Output, cancellation);
                 }
+
                 break;
             case P.HistoryEvent.EventTypeOneofCase.HistoryState:
                 if (e.HistoryState is { } hs && hs.OrchestrationState is { } os)
@@ -245,10 +260,12 @@ async Task ExternalizeHistoryEventAsync(P.HistoryEvent e, CancellationToken canc
                     await this.MaybeExternalizeAsync(v => os.Output = v, os.Output, cancellation);
                     await this.MaybeExternalizeAsync(v => os.CustomStatus = v, os.CustomStatus, cancellation);
                 }
+
                 break;
         }
     }
 
+    /// <inheritdoc/>
     protected override async Task ResolveResponsePayloadsAsync<TResponse>(TResponse response, CancellationToken cancellation)
     {
         // Backend Service -> Azure Managed Backend
@@ -267,6 +284,7 @@ protected override async Task ResolveResponsePayloadsAsync<TResponse>(TResponse
                 {
                     await this.ResolveEventPayloadsAsync(e, cancellation);
                 }
+
                 break;
             case P.QueryInstancesResponse r:
                 foreach (P.OrchestrationState s in r.OrchestrationState)
@@ -275,6 +293,7 @@ protected override async Task ResolveResponsePayloadsAsync<TResponse>(TResponse
                     await this.MaybeResolveAsync(v => s.Output = v, s.Output, cancellation);
                     await this.MaybeResolveAsync(v => s.CustomStatus = v, s.CustomStatus, cancellation);
                 }
+
                 break;
             case P.GetEntityResponse r when r.Entity is { } em:
                 await this.MaybeResolveAsync(v => em.SerializedState = v, em.SerializedState, cancellation);
@@ -284,6 +303,7 @@ protected override async Task ResolveResponsePayloadsAsync<TResponse>(TResponse
                 {
                     await this.MaybeResolveAsync(v => em.SerializedState = v, em.SerializedState, cancellation);
                 }
+
                 break;
             case P.WorkItem wi:
                 // Resolve activity input
@@ -331,6 +351,7 @@ protected override async Task ResolveResponsePayloadsAsync<TResponse>(TResponse
                         }
                     }
                 }
+
                 break;
         }
     }
@@ -344,96 +365,112 @@ async Task ResolveEventPayloadsAsync(P.HistoryEvent e, CancellationToken cancell
                 {
                     await this.MaybeResolveAsync(v => es.Input = v, es.Input, cancellation);
                 }
+
                 break;
             case P.HistoryEvent.EventTypeOneofCase.ExecutionCompleted:
                 if (e.ExecutionCompleted is { } ec)
                 {
                     await this.MaybeResolveAsync(v => ec.Result = v, ec.Result, cancellation);
                 }
+
                 break;
             case P.HistoryEvent.EventTypeOneofCase.EventRaised:
                 if (e.EventRaised is { } er)
                 {
                     await this.MaybeResolveAsync(v => er.Input = v, er.Input, cancellation);
                 }
+
                 break;
             case P.HistoryEvent.EventTypeOneofCase.TaskScheduled:
                 if (e.TaskScheduled is { } ts)
                 {
                     await this.MaybeResolveAsync(v => ts.Input = v, ts.Input, cancellation);
                 }
+
                 break;
             case P.HistoryEvent.EventTypeOneofCase.TaskCompleted:
                 if (e.TaskCompleted is { } tc)
                 {
                     await this.MaybeResolveAsync(v => tc.Result = v, tc.Result, cancellation);
                 }
+
                 break;
             case P.HistoryEvent.EventTypeOneofCase.SubOrchestrationInstanceCreated:
                 if (e.SubOrchestrationInstanceCreated is { } soc)
                 {
                     await this.MaybeResolveAsync(v => soc.Input = v, soc.Input, cancellation);
                 }
+
                 break;
             case P.HistoryEvent.EventTypeOneofCase.SubOrchestrationInstanceCompleted:
                 if (e.SubOrchestrationInstanceCompleted is { } sox)
                 {
                     await this.MaybeResolveAsync(v => sox.Result = v, sox.Result, cancellation);
                 }
+
                 break;
             case P.HistoryEvent.EventTypeOneofCase.EventSent:
                 if (e.EventSent is { } esent)
                 {
                     await this.MaybeResolveAsync(v => esent.Input = v, esent.Input, cancellation);
                 }
+
                 break;
             case P.HistoryEvent.EventTypeOneofCase.GenericEvent:
                 if (e.GenericEvent is { } ge)
                 {
                     await this.MaybeResolveAsync(v => ge.Data = v, ge.Data, cancellation);
                 }
+
                 break;
             case P.HistoryEvent.EventTypeOneofCase.ContinueAsNew:
                 if (e.ContinueAsNew is { } can)
                 {
                     await this.MaybeResolveAsync(v => can.Input = v, can.Input, cancellation);
                 }
+
                 break;
             case P.HistoryEvent.EventTypeOneofCase.ExecutionTerminated:
                 if (e.ExecutionTerminated is { } et)
                 {
                     await this.MaybeResolveAsync(v => et.Input = v, et.Input, cancellation);
                 }
+
                 break;
             case P.HistoryEvent.EventTypeOneofCase.ExecutionSuspended:
                 if (e.ExecutionSuspended is { } esus)
                 {
                     await this.MaybeResolveAsync(v => esus.Input = v, esus.Input, cancellation);
                 }
+
                 break;
             case P.HistoryEvent.EventTypeOneofCase.ExecutionResumed:
                 if (e.ExecutionResumed is { } eres)
                 {
                     await this.MaybeResolveAsync(v => eres.Input = v, eres.Input, cancellation);
                 }
+
                 break;
             case P.HistoryEvent.EventTypeOneofCase.EntityOperationSignaled:
                 if (e.EntityOperationSignaled is { } eos)
                 {
                     await this.MaybeResolveAsync(v => eos.Input = v, eos.Input, cancellation);
                 }
+
                 break;
             case P.HistoryEvent.EventTypeOneofCase.EntityOperationCalled:
                 if (e.EntityOperationCalled is { } eoc)
                 {
                     await this.MaybeResolveAsync(v => eoc.Input = v, eoc.Input, cancellation);
                 }
+
                 break;
             case P.HistoryEvent.EventTypeOneofCase.EntityOperationCompleted:
                 if (e.EntityOperationCompleted is { } ecomp)
                 {
                     await this.MaybeResolveAsync(v => ecomp.Output = v, ecomp.Output, cancellation);
                 }
+
                 break;
             case P.HistoryEvent.EventTypeOneofCase.HistoryState:
                 if (e.HistoryState is { } hs && hs.OrchestrationState is { } os)
@@ -442,6 +479,7 @@ async Task ResolveEventPayloadsAsync(P.HistoryEvent e, CancellationToken cancell
                     await this.MaybeResolveAsync(v => os.Output = v, os.Output, cancellation);
                     await this.MaybeResolveAsync(v => os.CustomStatus = v, os.CustomStatus, cancellation);
                 }
+
                 break;
         }
     }

src/Grpc.AzureManagedBackend/Grpc.AzureManagedBackend.csproj

@@ -0,0 +1,31 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFrameworks>netstandard2.0;net6.0</TargetFrameworks>
+    <PackageDescription>The gRPC Protobuf .NET services for Durable Task Framework.</PackageDescription>
+  </PropertyGroup>
+  <ItemGroup>
+    <PackageReference Include="Grpc.Tools" PrivateAssets="All" />
+    <PackageReference Include="Google.Protobuf" />
+  </ItemGroup>
+
+  <ItemGroup Condition="'$(TargetFramework)' == 'netstandard2.0'">
+    <PackageReference Include="Grpc.Core" />
+  </ItemGroup>
+
+  <ItemGroup Condition="'$(TargetFramework)' == 'net6.0'">
+    <PackageReference Include="Grpc.Net.Client" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <Protobuf Include="backend_service.proto"
+              GrpcServices="None"
+              Access="Public"
+              Namespace="Microsoft.DurableTask.AzureManagedBackend.Protobuf" />
+    <Protobuf Include="orchestrator_service.proto"
+            GrpcServices="None"
+            Access="Public"
+            Namespace="Microsoft.DurableTask.AzureManagedBackend.Protobuf" />
+  </ItemGroup>
+  
+</Project>

src/Grpc.AzureManagedBackend/README.md

@@ -0,0 +1,24 @@
+# Durable Task Protobuf
+
+This directory contains the protobuf definitions for the Durable Task SDK, which are used to generate the C# source code for the gRPC service contracts. The official protobuf definitions are maintained in the [Durable Task Protobuf repository](https://github.com/microsoft/durabletask-protobuf).
+
+## Updating the Protobuf Definitions
+
+To update the protobuf definitions in this directory, follow these steps:
+
+1. Make sure you have [PowerShell](https://learn.microsoft.com/powershell/scripting/install/installing-powershell) installed on your machine.
+2. Run the following command to download the latest protobuf definitions from the Durable Task SDK repository:
+
+```powershell
+.\refresh-protos.ps1
+```
+
+This script will download the latest protobuf definitions from the `https://github.com/microsoft/durabletask-protobuf` repository and copy them to this directory.
+
+By default, the latest versions of the protobufs are downloaded from the `main` branch. To specify an alternative branch, use the `-branch` parameter:
+
+```powershell
+.\refresh-protos.ps1 -branch <branch-name>
+```
+
+The `versions.txt` file in this directory contains the list of protobuf files and their commit hashes that were last downloaded. It is updated automatically by the `refresh-protos.ps1` script.

src/Grpc/backend_service.proto …zureManagedBackend/backend_service.protosrc/Grpc/backend_service.proto renamed to src/Grpc.AzureManagedBackend/backend_service.proto src/Grpc/backend_service.proto renamed to src/Grpc.AzureManagedBackend/backend_service.proto

@@ -5,7 +5,7 @@ syntax = "proto3";
 
 package durabletask.protos.backend.v1;
 
-option csharp_namespace = "Microsoft.DurableTask.Protobuf";
+option csharp_namespace = "Microsoft.DurableTask.AzureManagedBackend.Protobuf";
 option java_package = "com.microsoft.durabletask.implementation.protobuf";
 option go_package = "github.com/microsoft/durabletask-protobuf/internal/protos";