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();
}
