protected override async Task HandleCallAsyncCore(HttpContext httpContext, HttpContextServerCallContext serverCallContext)
{
// Decode request
var request = await httpContext.Request.BodyReader.ReadSingleMessageAsync <TRequest>(serverCallContext, Method.RequestMarshaller.ContextualDeserializer);
if (_pipelineInvoker == null)
{
GrpcActivatorHandle <TService> serviceHandle = default;
try
{
serviceHandle = ServiceActivator.Create(httpContext.RequestServices);
await _invoker(
serviceHandle.Instance,
request,
new HttpContextStreamWriter <TResponse>(serverCallContext, Method.ResponseMarshaller.ContextualSerializer),
serverCallContext);
}
finally
{
if (serviceHandle.Instance != null)
{
ServiceActivator.Release(serviceHandle);
}
}
}
else
{
await _pipelineInvoker(
request,
new HttpContextStreamWriter <TResponse>(serverCallContext, Method.ResponseMarshaller.ContextualSerializer),
serverCallContext);
}
}
public ServerStreamingServerCallHandler(
Method <TRequest, TResponse> method,
ServerStreamingServerMethod <TService, TRequest, TResponse> invoker,
GrpcServiceOptions serviceOptions,
ILoggerFactory loggerFactory,
IGrpcServiceActivator <TService> serviceActivator,
IServiceProvider serviceProvider)
: base(method, serviceOptions, loggerFactory, serviceActivator, serviceProvider)
{
_invoker = invoker;
if (ServiceOptions.HasInterceptors)
{
ServerStreamingServerMethod <TRequest, TResponse> resolvedInvoker = async(resolvedRequest, responseStream, resolvedContext) =>
{
GrpcActivatorHandle <TService> serviceHandle = default;
try
{
serviceHandle = ServiceActivator.Create(resolvedContext.GetHttpContext().RequestServices);
await _invoker(serviceHandle.Instance, resolvedRequest, responseStream, resolvedContext);
}
finally
{
if (serviceHandle.Instance != null)
{
ServiceActivator.Release(serviceHandle);
}
}
};
var interceptorPipeline = new InterceptorPipelineBuilder <TRequest, TResponse>(ServiceOptions.Interceptors, ServiceProvider);
_pipelineInvoker = interceptorPipeline.ServerStreamingPipeline(resolvedInvoker);
}
}
protected override async Task HandleCallAsyncCore(HttpContext httpContext, HttpContextServerCallContext serverCallContext)
{
// Disable request body data rate for client streaming
DisableMinRequestBodyDataRateAndMaxRequestBodySize(httpContext);
if (_pipelineInvoker == null)
{
GrpcActivatorHandle <TService> serviceHandle = default;
try
{
serviceHandle = ServiceActivator.Create(httpContext.RequestServices);
await _invoker(
serviceHandle.Instance,
new HttpContextStreamReader <TRequest>(serverCallContext, Method.RequestMarshaller.ContextualDeserializer),
new HttpContextStreamWriter <TResponse>(serverCallContext, Method.ResponseMarshaller.ContextualSerializer),
serverCallContext);
}
finally
{
if (serviceHandle.Instance != null)
{
ServiceActivator.Release(serviceHandle);
}
}
}
else
{
await _pipelineInvoker(
new HttpContextStreamReader <TRequest>(serverCallContext, Method.RequestMarshaller.ContextualDeserializer),
new HttpContextStreamWriter <TResponse>(serverCallContext, Method.ResponseMarshaller.ContextualSerializer),
serverCallContext);
}
}
protected override async Task HandleCallAsyncCore(HttpContext httpContext, HttpContextServerCallContext serverCallContext)
{
var requestPayload = await httpContext.Request.BodyReader.ReadSingleMessageAsync(serverCallContext);
serverCallContext.DeserializationContext.SetPayload(requestPayload);
var request = Method.RequestMarshaller.ContextualDeserializer(serverCallContext.DeserializationContext);
serverCallContext.DeserializationContext.SetPayload(null);
GrpcEventSource.Log.MessageReceived();
TResponse?response = null;
if (_pipelineInvoker == null)
{
GrpcActivatorHandle <TService> serviceHandle = default;
try
{
serviceHandle = ServiceActivator.Create(httpContext.RequestServices);
response = await _invoker(serviceHandle.Instance, request, serverCallContext);
}
finally
{
if (serviceHandle.Instance != null)
{
ServiceActivator.Release(serviceHandle);
}
}
}
else
{
response = await _pipelineInvoker(request, serverCallContext);
}
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, Method.ResponseMarshaller.ContextualSerializer, canFlush : false);
GrpcEventSource.Log.MessageSent();
}
protected override async Task HandleCallAsyncCore(HttpContext httpContext, HttpContextServerCallContext serverCallContext)
{
// Disable request body data rate for client streaming
DisableMinRequestBodyDataRateAndMaxRequestBodySize(httpContext);
TResponse?response = null;
if (_pipelineInvoker == null)
{
GrpcActivatorHandle <TService> serviceHandle = default;
try
{
serviceHandle = ServiceActivator.Create(httpContext.RequestServices);
response = await _invoker(
serviceHandle.Instance,
new HttpContextStreamReader <TRequest>(serverCallContext, Method.RequestMarshaller.ContextualDeserializer),
serverCallContext);
}
finally
{
if (serviceHandle.Instance != null)
{
ServiceActivator.Release(serviceHandle);
}
}
}
else
{
response = await _pipelineInvoker(
new HttpContextStreamReader <TRequest>(serverCallContext, Method.RequestMarshaller.ContextualDeserializer),
serverCallContext);
}
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, Method.ResponseMarshaller.ContextualSerializer, canFlush : false);
GrpcEventSource.Log.MessageSent();
}
