protected override async Task HandleCallAsyncCore(HttpContext httpContext, HttpContextServerCallContext serverCallContext)
{
// Disable request body data rate for client streaming
DisableMinRequestBodyDataRateAndMaxRequestBodySize(httpContext);
TResponse?response;
var streamReader = new HttpContextStreamReader <TRequest>(serverCallContext, MethodInvoker.Method.RequestMarshaller.ContextualDeserializer);
try
{
response = await _invoker.Invoke(httpContext, serverCallContext, streamReader);
}
finally
{
streamReader.Complete();
}
if (response == null)
{
// This is consistent with Grpc.Core when a null value is returned
throw new RpcException(new Status(StatusCode.Cancelled, "No message returned from method."));
}
// Check if deadline exceeded while method was invoked. If it has then skip trying to write
// the response message because it will always fail.
// Note that the call is still going so the deadline could still be exceeded after this point.
if (serverCallContext.DeadlineManager?.IsDeadlineExceededStarted ?? false)
{
return;
}
var responseBodyWriter = httpContext.Response.BodyWriter;
await responseBodyWriter.WriteSingleMessageAsync(response, serverCallContext, MethodInvoker.Method.ResponseMarshaller.ContextualSerializer);
}
public async Task MoveNext_TokenCancelledDuringMoveNext_CancelTask()
{
// Arrange
var ms = new SyncPointMemoryStream();
var httpContext = new DefaultHttpContext();
httpContext.Features.Set <IRequestBodyPipeFeature>(new TestRequestBodyPipeFeature(PipeReader.Create(ms)));
var serverCallContext = HttpContextServerCallContextHelper.CreateServerCallContext(httpContext);
var reader = new HttpContextStreamReader <HelloReply>(serverCallContext, MessageHelpers.ServiceMethod.ResponseMarshaller.ContextualDeserializer);
var cts = new CancellationTokenSource();
var nextTask = reader.MoveNext(cts.Token);
Assert.IsFalse(nextTask.IsCompleted);
Assert.IsFalse(nextTask.IsCanceled);
cts.Cancel();
try
{
await nextTask;
Assert.Fail();
}
catch (TaskCanceledException)
{
}
Assert.IsTrue(nextTask.IsCompleted);
Assert.IsTrue(nextTask.IsCanceled);
}
protected override async Task HandleCallAsyncCore(HttpContext httpContext, HttpContextServerCallContext serverCallContext)
{
// Disable request body data rate for client streaming
DisableMinRequestBodyDataRateAndMaxRequestBodySize(httpContext);
var streamReader = new HttpContextStreamReader <TRequest>(serverCallContext, MethodInvoker.Method.RequestMarshaller.ContextualDeserializer);
var response = await _invoker.Invoke(httpContext, serverCallContext, streamReader);
if (response == null)
{
// This is consistent with Grpc.Core when a null value is returned
throw new RpcException(new Status(StatusCode.Cancelled, "No message returned from method."));
}
if (serverCallContext.DeadlineManager != null && serverCallContext.DeadlineManager.CancellationToken.IsCancellationRequested)
{
// The cancellation token has been raised. Ensure that any DeadlineManager tasks have
// been completed before continuing.
await serverCallContext.DeadlineManager.CancellationProcessedTask;
// There is no point trying to write to the response because it has been finished.
if (serverCallContext.DeadlineManager.CallComplete)
{
return;
}
}
var responseBodyWriter = httpContext.Response.BodyWriter;
await responseBodyWriter.WriteMessageAsync(response, serverCallContext, MethodInvoker.Method.ResponseMarshaller.ContextualSerializer, canFlush : false);
}
protected override Task HandleCallAsyncCore(HttpContext httpContext, HttpContextServerCallContext serverCallContext)
{
// Disable request body data rate for client streaming
DisableMinRequestBodyDataRateAndMaxRequestBodySize(httpContext);
var streamReader = new HttpContextStreamReader <TRequest>(serverCallContext, MethodInvoker.Method.RequestMarshaller.ContextualDeserializer);
var streamWriter = new HttpContextStreamWriter <TResponse>(serverCallContext, MethodInvoker.Method.ResponseMarshaller.ContextualSerializer);
return(_invoker.Invoke(httpContext, serverCallContext, streamReader, streamWriter));
}
public void MoveNext_AlreadyCancelledToken_CancelReturnImmediately()
{
// Arrange
var ms = new SyncPointMemoryStream();
var httpContext = new DefaultHttpContext();
var serverCallContext = HttpContextServerCallContextHelper.CreateServerCallContext(httpContext);
var reader = new HttpContextStreamReader <HelloReply>(serverCallContext, MessageHelpers.ServiceMethod.ResponseMarshaller.ContextualDeserializer);
// Act
var nextTask = reader.MoveNext(new CancellationToken(true));
// Assert
Assert.IsTrue(nextTask.IsCompleted);
Assert.IsTrue(nextTask.IsCanceled);
}
protected override async Task HandleCallAsyncCore(HttpContext httpContext, HttpContextServerCallContext serverCallContext)
{
// Disable request body data rate for client streaming
DisableMinRequestBodyDataRateAndMaxRequestBodySize(httpContext);
var streamReader = new HttpContextStreamReader <TRequest>(serverCallContext, MethodInvoker.Method.RequestMarshaller.ContextualDeserializer);
var response = await _invoker.Invoke(httpContext, serverCallContext, streamReader);
if (response == null)
{
// This is consistent with Grpc.Core when a null value is returned
throw new RpcException(new Status(StatusCode.Cancelled, "No message returned from method."));
}
var responseBodyWriter = httpContext.Response.BodyWriter;
await responseBodyWriter.WriteMessageAsync(response, serverCallContext, MethodInvoker.Method.ResponseMarshaller.ContextualSerializer, canFlush : false);
}
public void MoveNext_AlreadyCancelledToken_CancelReturnImmediately()
{
// Arrange
var ms = new SyncPointMemoryStream();
var httpContext = new DefaultHttpContext();
var serverCallContext = HttpContextServerCallContextHelper.CreateServerCallContext(httpContext);
var reader = new HttpContextStreamReader <HelloReply>(serverCallContext, (data) =>
{
var message = new HelloReply();
message.MergeFrom(data);
return(message);
});
// Act
var nextTask = reader.MoveNext(new CancellationToken(true));
// Assert
Assert.IsTrue(nextTask.IsCompleted);
Assert.IsTrue(nextTask.IsCanceled);
}
public async Task MoveNext_TokenCancelledDuringMoveNext_CancelTask()
{
// Arrange
var ms = new SyncPointMemoryStream();
var testSink = new TestSink();
var testLoggerFactory = new TestLoggerFactory(testSink, enabled: true);
var httpContext = new DefaultHttpContext();
httpContext.Features.Set <IRequestBodyPipeFeature>(new TestRequestBodyPipeFeature(PipeReader.Create(ms)));
var serverCallContext = HttpContextServerCallContextHelper.CreateServerCallContext(httpContext, logger: testLoggerFactory.CreateLogger("Test"));
var reader = new HttpContextStreamReader <HelloReply>(serverCallContext, MessageHelpers.ServiceMethod.ResponseMarshaller.ContextualDeserializer);
var cts = new CancellationTokenSource();
var nextTask = reader.MoveNext(cts.Token);
Assert.IsFalse(nextTask.IsCompleted);
Assert.IsFalse(nextTask.IsCanceled);
cts.Cancel();
try
{
await nextTask;
Assert.Fail();
}
catch (TaskCanceledException)
{
}
Assert.IsTrue(nextTask.IsCompleted);
Assert.IsTrue(nextTask.IsCanceled);
Assert.AreEqual(1, testSink.Writes.Count);
Assert.AreEqual("ReadingMessage", testSink.Writes.First().EventId.Name);
}
public async Task MoveNext_TokenCancelledDuringMoveNext_CancelTask()
{
// Arrange
var ms = new SyncPointMemoryStream();
var httpContext = new DefaultHttpContext();
httpContext.Request.BodyReader = new StreamPipeReader(ms);
var serverCallContext = HttpContextServerCallContextHelper.CreateServerCallContext(httpContext);
var reader = new HttpContextStreamReader <HelloReply>(serverCallContext, (data) =>
{
var message = new HelloReply();
message.MergeFrom(data);
return(message);
});
var cts = new CancellationTokenSource();
var nextTask = reader.MoveNext(cts.Token);
Assert.IsFalse(nextTask.IsCompleted);
Assert.IsFalse(nextTask.IsCanceled);
cts.Cancel();
try
{
await nextTask;
Assert.Fail();
}
catch (TaskCanceledException)
{
}
Assert.IsTrue(nextTask.IsCompleted);
Assert.IsTrue(nextTask.IsCanceled);
}