public Task HandleCallAsync(HttpContext httpContext) { if (GrpcProtocolHelpers.IsInvalidContentType(httpContext, out var error)) { GrpcProtocolHelpers.SendHttpError(httpContext.Response, StatusCodes.Status415UnsupportedMediaType, StatusCode.Internal, error !); return(Task.CompletedTask); } var serverCallContext = new HttpContextServerCallContext(httpContext, ServiceOptions, Logger); httpContext.Features.Set <IServerCallContextFeature>(serverCallContext); GrpcProtocolHelpers.AddProtocolHeaders(httpContext.Response); try { serverCallContext.Initialize(); var handleCallTask = HandleCallAsyncCore(httpContext, serverCallContext); if (handleCallTask.IsCompletedSuccessfully) { return(serverCallContext.EndCallAsync()); } else { return(AwaitHandleCall(serverCallContext, Method, handleCallTask)); } } catch (Exception ex) { return(serverCallContext.ProcessHandlerErrorAsync(ex, Method.Name)); }
protected override async Task HandleCallAsyncCore(HttpContext httpContext) { var serverCallContext = CreateServerCallContext(httpContext); GrpcProtocolHelpers.AddProtocolHeaders(httpContext.Response); try { serverCallContext.Initialize(); var requestPayload = await httpContext.Request.BodyReader.ReadSingleMessageAsync(serverCallContext); var request = Method.RequestMarshaller.Deserializer(requestPayload); TResponse?response = null; if (_pipelineInvoker == null) { var activator = httpContext.RequestServices.GetRequiredService <IGrpcServiceActivator <TService> >(); TService?service = null; try { service = activator.Create(); response = await _invoker(service, request, serverCallContext); } finally { if (service != null) { activator.Release(service); } } } 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.Serializer); await serverCallContext.EndCallAsync(); } catch (Exception ex) { serverCallContext.ProcessHandlerError(ex, Method.Name); } finally { serverCallContext.Dispose(); } }
public Task HandleCallAsync(HttpContext httpContext) { if (GrpcProtocolHelpers.IsInvalidContentType(httpContext, out var error)) { // This might be a CORS preflight request and CORS middleware hasn't been configured if (HttpMethods.IsOptions(httpContext.Request.Method)) { GrpcServerLog.UnhandledCorsPreflightRequest(Logger); GrpcProtocolHelpers.BuildHttpErrorResponse(httpContext.Response, StatusCodes.Status405MethodNotAllowed, StatusCode.Internal, "Unhandled CORS preflight request received. CORS may not be configured correctly in the application."); httpContext.Response.Headers[HeaderNames.Allow] = HttpMethods.Post; return(Task.CompletedTask); } else { GrpcServerLog.UnsupportedRequestContentType(Logger, httpContext.Request.ContentType); GrpcProtocolHelpers.BuildHttpErrorResponse(httpContext.Response, StatusCodes.Status415UnsupportedMediaType, StatusCode.Internal, error); return(Task.CompletedTask); } } if (httpContext.Request.Protocol != GrpcProtocolConstants.Http2Protocol && httpContext.Request.Protocol != GrpcProtocolConstants.Http20Protocol) { GrpcServerLog.UnsupportedRequestProtocol(Logger, httpContext.Request.Protocol); var protocolError = $"Request protocol '{httpContext.Request.Protocol}' is not supported."; GrpcProtocolHelpers.BuildHttpErrorResponse(httpContext.Response, StatusCodes.Status426UpgradeRequired, StatusCode.Internal, protocolError); httpContext.Response.Headers[HeaderNames.Upgrade] = GrpcProtocolConstants.Http2Protocol; return(Task.CompletedTask); } var serverCallContext = new HttpContextServerCallContext(httpContext, MethodInvoker.Options, typeof(TRequest), typeof(TResponse), Logger); httpContext.Features.Set <IServerCallContextFeature>(serverCallContext); GrpcProtocolHelpers.AddProtocolHeaders(httpContext.Response); try { serverCallContext.Initialize(); var handleCallTask = HandleCallAsyncCore(httpContext, serverCallContext); if (handleCallTask.IsCompletedSuccessfully) { return(serverCallContext.EndCallAsync()); } else { return(AwaitHandleCall(serverCallContext, MethodInvoker.Method, handleCallTask)); } } catch (Exception ex) { return(serverCallContext.ProcessHandlerErrorAsync(ex, MethodInvoker.Method.Name)); }
protected override async Task HandleCallAsyncCore(HttpContext httpContext) { var serverCallContext = CreateServerCallContext(httpContext); GrpcProtocolHelpers.AddProtocolHeaders(httpContext.Response); try { serverCallContext.Initialize(); // Decode request var requestPayload = await httpContext.Request.BodyReader.ReadSingleMessageAsync(serverCallContext); var request = Method.RequestMarshaller.Deserializer(requestPayload); if (_pipelineInvoker == null) { var activator = httpContext.RequestServices.GetRequiredService <IGrpcServiceActivator <TService> >(); TService?service = null; try { service = activator.Create(); await _invoker( service, request, new HttpContextStreamWriter <TResponse>(serverCallContext, Method.ResponseMarshaller.Serializer), serverCallContext); } finally { if (service != null) { activator.Release(service); } } } else { await _pipelineInvoker( request, new HttpContextStreamWriter <TResponse>(serverCallContext, Method.ResponseMarshaller.Serializer), serverCallContext); } await serverCallContext.EndCallAsync(); } catch (Exception ex) { serverCallContext.ProcessHandlerError(ex, Method.Name); } finally { serverCallContext.Dispose(); } }
protected override async Task HandleCallAsyncCore(HttpContext httpContext) { GrpcProtocolHelpers.AddProtocolHeaders(httpContext.Response); var serverCallContext = new HttpContextServerCallContext(httpContext, ServiceOptions, Logger); var activator = httpContext.RequestServices.GetRequiredService <IGrpcServiceActivator <TService> >(); TService service = null; TResponse response = null; try { serverCallContext.Initialize(); var requestPayload = await httpContext.Request.BodyPipe.ReadSingleMessageAsync(serverCallContext); var request = Method.RequestMarshaller.Deserializer(requestPayload); service = activator.Create(); response = await _invoker( service, 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 responseBodyPipe = httpContext.Response.BodyPipe; await responseBodyPipe.WriteMessageAsync(response, serverCallContext, Method.ResponseMarshaller.Serializer); } catch (Exception ex) { serverCallContext.ProcessHandlerError(ex, Method.Name); } finally { serverCallContext.Dispose(); if (service != null) { activator.Release(service); } } httpContext.Response.ConsolidateTrailers(serverCallContext); // Flush any buffered content await httpContext.Response.BodyPipe.FlushAsync(); }
protected override async Task HandleCallAsyncCore(HttpContext httpContext) { // Disable request body data rate for client streaming DisableMinRequestBodyDataRate(httpContext); var serverCallContext = CreateServerCallContext(httpContext); GrpcProtocolHelpers.AddProtocolHeaders(httpContext.Response); try { serverCallContext.Initialize(); if (_pipelineInvoker == null) { var activator = httpContext.RequestServices.GetRequiredService <IGrpcServiceActivator <TService> >(); TService?service = null; try { service = activator.Create(); await _invoker( service, new HttpContextStreamReader <TRequest>(serverCallContext, Method.RequestMarshaller.Deserializer), new HttpContextStreamWriter <TResponse>(serverCallContext, Method.ResponseMarshaller.Serializer), serverCallContext); } finally { if (service != null) { activator.Release(service); } } } else { await _pipelineInvoker( new HttpContextStreamReader <TRequest>(serverCallContext, Method.RequestMarshaller.Deserializer), new HttpContextStreamWriter <TResponse>(serverCallContext, Method.ResponseMarshaller.Serializer), serverCallContext); } await serverCallContext.EndCallAsync(); } catch (Exception ex) { serverCallContext.ProcessHandlerError(ex, Method.Name); } finally { serverCallContext.Dispose(); } }
public Task HandleCallAsync(HttpContext httpContext) { if (GrpcProtocolHelpers.IsInvalidContentType(httpContext, out var error)) { Log.UnsupportedRequestContentType(Logger, httpContext.Request.ContentType); GrpcProtocolHelpers.BuildHttpErrorResponse(httpContext.Response, StatusCodes.Status415UnsupportedMediaType, StatusCode.Internal, error); return(Task.CompletedTask); } if (httpContext.Request.Protocol != GrpcProtocolConstants.Http2Protocol && httpContext.Request.Protocol != GrpcProtocolConstants.Http20Protocol) { Log.UnsupportedRequestProtocol(Logger, httpContext.Request.Protocol); var protocolError = $"Request protocol '{httpContext.Request.Protocol}' is not supported."; GrpcProtocolHelpers.BuildHttpErrorResponse(httpContext.Response, StatusCodes.Status426UpgradeRequired, StatusCode.Internal, protocolError); httpContext.Response.Headers[HeaderNames.Upgrade] = GrpcProtocolConstants.Http2Protocol; return(Task.CompletedTask); } var serverCallContext = new HttpContextServerCallContext(httpContext, ServiceOptions, Logger); httpContext.Features.Set <IServerCallContextFeature>(serverCallContext); GrpcProtocolHelpers.AddProtocolHeaders(httpContext.Response); try { serverCallContext.Initialize(); var handleCallTask = HandleCallAsyncCore(httpContext, serverCallContext); if (handleCallTask.IsCompletedSuccessfully) { return(serverCallContext.EndCallAsync()); } else { return(AwaitHandleCall(serverCallContext, Method, handleCallTask)); } } catch (Exception ex) { return(serverCallContext.ProcessHandlerErrorAsync(ex, Method.Name)); }
protected override async Task HandleCallAsyncCore(HttpContext httpContext) { GrpcProtocolHelpers.AddProtocolHeaders(httpContext.Response); var serverCallContext = new HttpContextServerCallContext(httpContext, ServiceOptions, Logger); var activator = httpContext.RequestServices.GetRequiredService <IGrpcServiceActivator <TService> >(); TService service = null; try { serverCallContext.Initialize(); // Decode request var requestPayload = await httpContext.Request.BodyPipe.ReadSingleMessageAsync(serverCallContext); var request = Method.RequestMarshaller.Deserializer(requestPayload); service = activator.Create(); await _invoker( service, request, new HttpContextStreamWriter <TResponse>(serverCallContext, Method.ResponseMarshaller.Serializer), serverCallContext); } catch (Exception ex) { serverCallContext.ProcessHandlerError(ex, Method.Name); } finally { serverCallContext.Dispose(); if (service != null) { activator.Release(service); } } httpContext.Response.ConsolidateTrailers(serverCallContext); // Flush any buffered content await httpContext.Response.BodyPipe.FlushAsync(); }
public Task HandleCallAsync(HttpContext httpContext) { if (GrpcProtocolHelpers.IsInvalidContentType(httpContext, out var error)) { return(ProcessInvalidContentTypeRequest(httpContext, error)); } if (!GrpcProtocolConstants.IsHttp2(httpContext.Request.Protocol) #if NET6_0_OR_GREATER && !GrpcProtocolConstants.IsHttp3(httpContext.Request.Protocol) #endif ) { return(ProcessNonHttp2Request(httpContext)); } var serverCallContext = new HttpContextServerCallContext(httpContext, MethodInvoker.Options, typeof(TRequest), typeof(TResponse), Logger); httpContext.Features.Set <IServerCallContextFeature>(serverCallContext); GrpcProtocolHelpers.AddProtocolHeaders(httpContext.Response); try { serverCallContext.Initialize(); var handleCallTask = HandleCallAsyncCore(httpContext, serverCallContext); if (handleCallTask.IsCompletedSuccessfully) { return(serverCallContext.EndCallAsync()); } else { return(AwaitHandleCall(serverCallContext, MethodInvoker.Method, handleCallTask)); } } catch (Exception ex) { return(serverCallContext.ProcessHandlerErrorAsync(ex, MethodInvoker.Method.Name)); }
protected override async Task HandleCallAsyncCore(HttpContext httpContext) { var serverCallContext = CreateServerCallContext(httpContext); GrpcProtocolHelpers.AddProtocolHeaders(httpContext.Response); var activator = httpContext.RequestServices.GetRequiredService <IGrpcServiceActivator <TService> >(); TService service = null; try { serverCallContext.Initialize(); // Decode request var requestPayload = await httpContext.Request.BodyReader.ReadSingleMessageAsync(serverCallContext); var request = Method.RequestMarshaller.Deserializer(requestPayload); if (ServiceOptions.Interceptors.IsEmpty) { try { service = activator.Create(); await _invoker( service, request, new HttpContextStreamWriter <TResponse>(serverCallContext, Method.ResponseMarshaller.Serializer), serverCallContext); } finally { if (service != null) { activator.Release(service); } } } else { ServerStreamingServerMethod <TRequest, TResponse> resolvedInvoker = async(request, responseStream, resolvedContext) => { try { service = activator.Create(); await _invoker( service, request, responseStream, resolvedContext); } finally { if (service != null) { activator.Release(service); } } }; // The list is reversed during construction so the first interceptor is built last and invoked first for (var i = ServiceOptions.Interceptors.Count - 1; i >= 0; i--) { resolvedInvoker = BuildInvoker(ServiceOptions.Interceptors[i], resolvedInvoker); } await resolvedInvoker( request, new HttpContextStreamWriter <TResponse>(serverCallContext, Method.ResponseMarshaller.Serializer), serverCallContext); } await serverCallContext.EndCallAsync(); } catch (Exception ex) { serverCallContext.ProcessHandlerError(ex, Method.Name); } finally { serverCallContext.Dispose(); if (service != null) { activator.Release(service); } } }
protected override async Task HandleCallAsyncCore(HttpContext httpContext) { var serverCallContext = CreateServerCallContext(httpContext); GrpcProtocolHelpers.AddProtocolHeaders(httpContext.Response); var activator = httpContext.RequestServices.GetRequiredService <IGrpcServiceActivator <TService> >(); TService service = null; TResponse response = null; try { serverCallContext.Initialize(); if (ServiceOptions.Interceptors.IsEmpty) { try { service = activator.Create(); response = await _invoker( service, new HttpContextStreamReader <TRequest>(serverCallContext, Method.RequestMarshaller.Deserializer), serverCallContext); } finally { if (service != null) { activator.Release(service); } } } else { ClientStreamingServerMethod <TRequest, TResponse> resolvedInvoker = async(resolvedRequestStream, resolvedContext) => { try { service = activator.Create(); return(await _invoker( service, resolvedRequestStream, resolvedContext)); } finally { if (service != null) { activator.Release(service); } } }; // The list is reversed during construction so the first interceptor is built last and invoked first for (var i = ServiceOptions.Interceptors.Count - 1; i >= 0; i--) { resolvedInvoker = BuildInvoker(ServiceOptions.Interceptors[i], resolvedInvoker); } response = await resolvedInvoker( new HttpContextStreamReader <TRequest>(serverCallContext, Method.RequestMarshaller.Deserializer), 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.Serializer); await serverCallContext.EndCallAsync(); } catch (Exception ex) { serverCallContext.ProcessHandlerError(ex, Method.Name); } finally { serverCallContext.Dispose(); } }