Merge branch 'master' into chore/#1239_PackageCleanup

daprdocs/content/en/dotnet-sdk-docs/dotnet-actors/dotnet-actors-howto.md

@@ -319,11 +319,8 @@ namespace MyActorService
 
             app.UseRouting();
 
-            app.UseEndpoints(endpoints =>
-            {
-                // Register actors handlers that interface with the Dapr runtime.
-                endpoints.MapActorsHandlers();
-            });
+            // Register actors handlers that interface with the Dapr runtime.
+            app.MapActorsHandlers();
         }
     }
 }

daprdocs/content/en/dotnet-sdk-docs/dotnet-client/_index.md

@@ -21,13 +21,16 @@ The .NET SDK allows you to interface with all of the [Dapr building blocks]({{<
 
 ### Invoke a service
 
+#### HTTP
 You can either use the `DaprClient` or `System.Net.Http.HttpClient` to invoke your services.
 
 {{< tabs SDK HTTP>}}
 
 {{% codetab %}}
 ```csharp
-using var client = new DaprClientBuilder().Build();
+using var client = new DaprClientBuilder().
+                UseTimeout(TimeSpan.FromSeconds(2)). // Optionally, set a timeout
+                Build(); 
 
 // Invokes a POST method named "deposit" that takes input of type "Transaction"
 var data = new { id = "17", amount = 99m };
@@ -40,15 +43,33 @@ Console.WriteLine("Returned: id:{0} | Balance:{1}", account.Id, account.Balance)
 ```csharp
 var client = DaprClient.CreateInvokeHttpClient(appId: "routing");
 
+// To set a timeout on the HTTP client:
+client.Timeout = TimeSpan.FromSeconds(2);
+
 var deposit = new Transaction  { Id = "17", Amount = 99m };
 var response = await client.PostAsJsonAsync("/deposit", deposit, cancellationToken);
 var account = await response.Content.ReadFromJsonAsync<Account>(cancellationToken: cancellationToken);
 Console.WriteLine("Returned: id:{0} | Balance:{1}", account.Id, account.Balance);
 ```
 {{% /codetab %}}
-
 {{< /tabs >}}
 
+#### gRPC
+You can use the `DaprClient` to invoke your services over gRPC.
+{{% codetab %}}
+```csharp
+using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(20));
+var invoker = DaprClient.CreateInvocationInvoker(appId: myAppId, daprEndpoint: serviceEndpoint);
+var client = new MyService.MyServiceClient(invoker);
+
+var options = new CallOptions(cancellationToken: cts.Token, deadline: DateTime.UtcNow.AddSeconds(1));
+await client.MyMethodAsync(new Empty(), options);
+
+Assert.Equal(StatusCode.DeadlineExceeded, ex.StatusCode);
+```
+{{% /codetab %}}
+
+
 - For a full guide on service invocation visit [How-To: Invoke a service]({{< ref howto-invoke-discover-services.md >}}).
 
 ### Save & get application state

src/Dapr.Client/DaprClientBuilder.cs

@@ -57,6 +57,7 @@ public DaprClientBuilder()
         // property exposed for testing purposes
         internal GrpcChannelOptions GrpcChannelOptions { get; private set; }
         internal string DaprApiToken { get; private set; }
+        internal TimeSpan Timeout { get; private set; } 
 
         /// <summary>
         /// Overrides the HTTP endpoint used by <see cref="DaprClient" /> for communicating with the Dapr runtime.
@@ -136,6 +137,17 @@ public DaprClientBuilder UseDaprApiToken(string apiToken)
             return this;
         }
 
+        /// <summary>
+        ///  Sets the timeout for the HTTP client used by the <see cref="DaprClient" />.
+        /// </summary>
+        /// <param name="timeout"></param>
+        /// <returns></returns>
+        public DaprClientBuilder UseTimeout(TimeSpan timeout)
+        {
+            this.Timeout = timeout;
+            return this;
+        }
+
         /// <summary>
         /// Builds a <see cref="DaprClient" /> instance from the properties of the builder.
         /// </summary>
@@ -162,9 +174,16 @@ public DaprClient Build()
 
             var channel = GrpcChannel.ForAddress(this.GrpcEndpoint, this.GrpcChannelOptions);
             var client = new Autogenerated.Dapr.DaprClient(channel);
-
+
+
             var apiTokenHeader = DaprClient.GetDaprApiTokenHeader(this.DaprApiToken);
             var httpClient = HttpClientFactory is object ? HttpClientFactory() : new HttpClient();
+
+            if (this.Timeout > TimeSpan.Zero)
+            {
+                httpClient.Timeout = this.Timeout;
+            }
+
             return new DaprClientGrpc(channel, client, httpClient, httpEndpoint, this.JsonSerializerOptions, apiTokenHeader);
         }
     }

src/Dapr.Client/StateQueryResponse.cs

@@ -11,6 +11,7 @@ You may obtain a copy of the License at
 limitations under the License.
 */
 
+#nullable enable
 using System.Collections.Generic;
 
 namespace Dapr.Client
@@ -75,9 +76,9 @@ public StateQueryItem(string key, TValue data, string etag, string error)
         public string Key { get; }
 
         /// <summary>
-        /// The data of the the key from the matched query.
+        /// The data of the key from the matched query.
         /// </summary>
-        public TValue Data { get; }
+        public TValue? Data { get; }
 
         /// <summary>
         /// The ETag for the key from the matched query.

src/Dapr.Workflow/WorkflowContext.cs

@@ -245,9 +245,9 @@ public abstract Task<TResult> CallChildWorkflowAsync<TResult>(
         /// exception will be surfaced to the parent workflow, just like it is when an activity task fails with an
         /// exception. Child workflows also support automatic retry policies.
         /// </para><para>
-        /// Because child workflows are independent of their parents, terminating a parent workflow does not affect
-        /// any child workflows. You must terminate each child workflow independently using its instance ID, which
-        /// is specified by <see cref="ChildWorkflowTaskOptions.InstanceId" />.
+        /// Terminating a parent workflow terminates all the child workflows created by the workflow instance. See the documentation at
+        /// https://docs.dapr.io/developing-applications/building-blocks/workflow/workflow-features-concepts/#child-workflows regarding
+        /// the terminate workflow API for more information.
         /// </para>
         /// </remarks>
         /// <param name="workflowName">The name of the workflow to call.</param>

test/Dapr.AspNetCore.Test/DaprClientBuilderTest.cs

@@ -14,6 +14,7 @@
 using System;
 using System.Text.Json;
 using Dapr.Client;
+using Grpc.Core;
 using Grpc.Net.Client;
 using Xunit;
 
@@ -110,5 +111,15 @@ public void DaprClientBuilder_ApiTokenNotSet_EmptyApiTokenHeader()
             var entry = DaprClient.GetDaprApiTokenHeader(builder.DaprApiToken);
             Assert.Equal(default, entry);
         }
+
+        [Fact]
+        public void DaprClientBuilder_SetsTimeout()
+        {
+            var builder = new DaprClientBuilder();
+            builder.UseTimeout(TimeSpan.FromSeconds(2));
+            builder.Build();
+            Assert.Equal(2, builder.Timeout.Seconds);
+        }
     }
+
 }

test/Dapr.E2E.Test.App.Grpc/Proto/message.proto

@@ -25,6 +25,7 @@ service Messager {
   rpc GetMessage(GetMessageRequest) returns (MessageResponse);
   // Send a series of broadcast messages.
   rpc StreamBroadcast(stream Broadcast) returns (stream MessageResponse);
+  rpc DelayedResponse(google.protobuf.Empty) returns (google.protobuf.Empty);
 }
 
 message SendMessageRequest {

test/Dapr.E2E.Test.App.Grpc/Services/MessagerService.cs

@@ -11,6 +11,7 @@
 // limitations under the License.
 // ------------------------------------------------------------------------
 
+using System;
 using System.Threading.Tasks;
 using Google.Protobuf.WellKnownTypes;
 using Grpc.Core;
@@ -44,5 +45,11 @@ public override async Task StreamBroadcast(IAsyncStreamReader<Broadcast> request
                 await responseStream.WriteAsync(new MessageResponse { Message = request.Message });
             }
         }
+
+        public override async Task<Empty> DelayedResponse(Empty request, ServerCallContext context)
+        {
+            await Task.Delay(TimeSpan.FromSeconds(2));
+            return new Empty();
+        }
     }
 }

test/Dapr.E2E.Test.App/Controllers/TestController.cs

@@ -65,5 +65,14 @@ public ActionResult<Account> AccountDetailsRequiresApiToken(Transaction transact
             };
             return account;
         }
+
+        [Authorize("Dapr")]
+        [HttpGet("DelayedResponse")]
+        public async Task<IActionResult> DelayedResponse()
+        {
+            await Task.Delay(TimeSpan.FromSeconds(2));
+            return Ok();
+        }
+
     }
 }

test/Dapr.E2E.Test/ServiceInvocation/E2ETests.GrpcProxyInvocationTests.cs

@@ -15,6 +15,7 @@
 using System.Threading;
 using System.Threading.Tasks;
 using Dapr.Client;
+using Google.Protobuf.WellKnownTypes;
 using Grpc.Core;
 using Xunit;
 using Xunit.Abstractions;
@@ -77,5 +78,21 @@ public async Task TestGrpcProxyStreamingBroadcast()
                 await responseTask;
             }
         }
+
+        [Fact]
+        public async Task TestGrpcServiceInvocationWithTimeout()
+        {
+            using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(20));
+            var invoker = DaprClient.CreateInvocationInvoker(appId: this.AppId, daprEndpoint: this.GrpcEndpoint);
+            var client = new Messager.MessagerClient(invoker);
+
+            var options = new CallOptions(cancellationToken: cts.Token, deadline: DateTime.UtcNow.AddSeconds(1));
+            var ex = await Assert.ThrowsAsync<RpcException>(async () =>
+                {
+                    await client.DelayedResponseAsync(new Empty(), options);
+                });
+
+            Assert.Equal(StatusCode.DeadlineExceeded, ex.StatusCode);
+        }
     }
 }

test/Dapr.E2E.Test/ServiceInvocation/E2ETests.ServiceInvocationTests.cs

@@ -13,10 +13,15 @@
 namespace Dapr.E2E.Test
 {
     using System;
+    using System.Net;
+    using System.Net.Http;
     using System.Net.Http.Json;
+    using System.Net.Sockets;
     using System.Threading;
     using System.Threading.Tasks;
     using Dapr.Client;
+    using Google.Protobuf.WellKnownTypes;
+    using Grpc.Core;
     using Xunit;
 
     public partial class E2ETests
@@ -58,6 +63,25 @@ public async Task TestServiceInvocationRequiresApiToken()
             Assert.Equal("1", account.Id);
             Assert.Equal(150, account.Balance);
         }
+
+        [Fact]
+        public async Task TestHttpServiceInvocationWithTimeout()
+        {
+            using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(20));
+            using var client = new DaprClientBuilder()
+                        .UseHttpEndpoint(this.HttpEndpoint)
+                        .UseTimeout(TimeSpan.FromSeconds(1))
+                        .Build();
+
+            await Assert.ThrowsAsync<TaskCanceledException>(async () =>
+            {
+                await client.InvokeMethodAsync<HttpResponseMessage>(
+                    appId: this.AppId,
+                    methodName: "DelayedResponse",
+                    httpMethod: new HttpMethod("GET"),
+                    cancellationToken: cts.Token);
+            });
+        }
     }
 
     internal class Transaction