public void Deadline_NoTimeoutHeader_MaxValue() { // Arrange var httpContext = new DefaultHttpContext(); var context = new HttpContextServerCallContext(httpContext); // Act context.Initialize(); // Assert Assert.AreEqual(DateTime.MaxValue, context.Deadline); }
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(); }
public override async Task HandleCallAsync(HttpContext httpContext) { httpContext.Response.ContentType = "application/grpc"; httpContext.Response.Headers.Append("grpc-encoding", "identity"); var serverCallContext = new HttpContextServerCallContext(httpContext, ServiceOptions, Logger); var activator = httpContext.RequestServices.GetRequiredService <IGrpcServiceActivator <TService> >(); TService service = null; TResponse response = null; try { serverCallContext.Initialize(); service = activator.Create(); response = await _invoker( service, new HttpContextStreamReader <TRequest>(httpContext, 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, "Cancelled")); } 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(); }
public static HttpContextServerCallContext CreateServerCallContext( HttpContext httpContext = null, GrpcServiceOptions serviceOptions = null, ILogger logger = null) { var context = new HttpContextServerCallContext( httpContext ?? new DefaultHttpContext(), serviceOptions ?? new GrpcServiceOptions(), logger ?? NullLogger.Instance); context.Initialize(); return(context); }
public void Deadline_UnsupportedLength_ThrowsError(string header) { // Arrange var httpContext = new DefaultHttpContext(); httpContext.Request.Headers[GrpcProtocolConstants.TimeoutHeader] = header; var context = new HttpContextServerCallContext(httpContext); // Act var ex = Assert.Catch <InvalidOperationException>(() => context.Initialize()); // Assert Assert.AreEqual("A timeout greater than 2147483647 milliseconds is not supported.", ex.Message); }
public void Deadline_ParseInvalidHeader_ThrowsError(string header) { // Arrange var httpContext = new DefaultHttpContext(); httpContext.Request.Headers[GrpcProtocolConstants.TimeoutHeader] = header; var context = new HttpContextServerCallContext(httpContext); // Act var ex = Assert.Catch <InvalidOperationException>(() => context.Initialize()); // Assert Assert.AreEqual("Error reading grpc-timeout value.", ex.Message); }
public void Deadline_ParseValidHeader_ReturnDeadline(string header, long ticks) { // Arrange var httpContext = new DefaultHttpContext(); httpContext.Request.Headers[GrpcProtocolConstants.TimeoutHeader] = header; var context = new HttpContextServerCallContext(httpContext); context.Clock = TestClock; // Act context.Initialize(); // Assert Assert.AreEqual(TestClock.UtcNow.Add(TimeSpan.FromTicks(ticks)), context.Deadline); }
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)); }
public override async Task HandleCallAsync(HttpContext httpContext) { httpContext.Response.ContentType = "application/grpc"; httpContext.Response.Headers.Append("grpc-encoding", "identity"); 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 static HttpContextServerCallContext CreateServerCallContext( HttpContext?httpContext = null, GrpcServiceOptions?serviceOptions = null, ILogger?logger = null, bool initialize = true) { var context = new HttpContextServerCallContext( httpContext ?? new DefaultHttpContext(), serviceOptions ?? new GrpcServiceOptions(), logger ?? NullLogger.Instance); if (initialize) { context.Initialize(); } return(context); }
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) { GrpcProtocolHelpers.AddProtocolHeaders(httpContext.Response); var serverCallContext = new HttpContextServerCallContext(httpContext, ServiceOptions, Logger); var activator = httpContext.RequestServices.GetRequiredService <IGrpcServiceActivator <TService> >(); TService service = null; try { serverCallContext.Initialize(); service = activator.Create(); await _invoker( service, new HttpContextStreamReader <TRequest>(serverCallContext, Method.RequestMarshaller.Deserializer), 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 async Task CancellationToken_WithDeadline_CancellationRequested() { // Arrange var httpContext = new DefaultHttpContext(); httpContext.Request.Headers[GrpcProtocolConstants.TimeoutHeader] = "1S"; var context = new HttpContextServerCallContext(httpContext); context.Initialize(); // Act & Assert try { await Task.Delay(int.MaxValue, context.CancellationToken).DefaultTimeout(); Assert.Fail(); } catch (TaskCanceledException) { // Assert Assert.IsTrue(context.CancellationToken.IsCancellationRequested); } }
public static HttpContextServerCallContext CreateServerCallContext( HttpContext?httpContext = null, List <ICompressionProvider>?compressionProviders = null, string?responseCompressionAlgorithm = null, CompressionLevel?responseCompressionLevel = null, int?maxSendMessageSize = null, int?maxReceiveMessageSize = null, ILogger?logger = null, WriteOptions?writeOptions = null, bool initialize = true) { var options = CreateMethodOptions( compressionProviders, responseCompressionAlgorithm, responseCompressionLevel, maxSendMessageSize, maxReceiveMessageSize); var context = new HttpContextServerCallContext( httpContext ?? new DefaultHttpContext(), options, typeof(object), typeof(object), logger ?? NullLogger.Instance); if (writeOptions != null) { context.WriteOptions = writeOptions; } if (initialize) { context.Initialize(); } return(context); }
static MessageHelpers() { TestServerCallContext.Initialize(); }