private async void ProcessRequestAsync(object requestContextObj)
{
var requestContext = requestContextObj as RequestContext;
try
{
if (Stopping)
{
SetFatalResponse(requestContext, 503);
return;
}
object context = null;
Interlocked.Increment(ref _outstandingRequests);
try
{
var featureContext = new FeatureContext(requestContext);
context = _application.CreateContext(featureContext.Features);
try
{
await _application.ProcessRequestAsync(context).SupressContext();
await featureContext.CompleteAsync();
}
finally
{
await featureContext.OnCompleted();
}
_application.DisposeContext(context, null);
requestContext.Dispose();
}
catch (Exception ex)
{
LogHelper.LogException(_logger, "ProcessRequestAsync", ex);
_application.DisposeContext(context, ex);
if (requestContext.Response.HasStarted)
{
requestContext.Abort();
}
else
{
// We haven't sent a response yet, try to send a 500 Internal Server Error
requestContext.Response.Headers.IsReadOnly = false;
requestContext.Response.Trailers.IsReadOnly = false;
requestContext.Response.Headers.Clear();
requestContext.Response.Trailers.Clear();
SetFatalResponse(requestContext, 500);
}
}
finally
{
if (Interlocked.Decrement(ref _outstandingRequests) == 0 && Stopping)
{
LogHelper.LogInfo(_logger, "All requests drained.");
_shutdownSignal.TrySetResult(0);
}
}
}
catch (Exception ex)
{
LogHelper.LogException(_logger, "ProcessRequestAsync", ex);
requestContext.Abort();
}
}
public StandardFeatureCollection(FeatureContext featureContext)
{
_featureContext = featureContext;
}
private static object ReturnIdentity(FeatureContext featureContext)
{
return(featureContext);
}
public async void Execute()
{
var messagePump = MessagePump;
var application = messagePump.Application;
try
{
if (messagePump.Stopping)
{
SetFatalResponse(503);
return;
}
object context = null;
messagePump.IncrementOutstandingRequest();
try
{
var featureContext = new FeatureContext(this);
context = application.CreateContext(featureContext.Features);
try
{
await application.ProcessRequestAsync(context);
await featureContext.CompleteAsync();
}
finally
{
await featureContext.OnCompleted();
}
application.DisposeContext(context, null);
Dispose();
}
catch (Exception ex)
{
Logger.LogError(LoggerEventIds.RequestProcessError, ex, "ProcessRequestAsync");
application.DisposeContext(context, ex);
if (Response.HasStarted)
{
// HTTP/2 INTERNAL_ERROR = 0x2 https://tools.ietf.org/html/rfc7540#section-7
// Otherwise the default is Cancel = 0x8.
SetResetCode(2);
Abort();
}
else
{
// We haven't sent a response yet, try to send a 500 Internal Server Error
Response.Headers.IsReadOnly = false;
Response.Trailers.IsReadOnly = false;
Response.Headers.Clear();
Response.Trailers.Clear();
if (ex is BadHttpRequestException badHttpRequestException)
{
SetFatalResponse(badHttpRequestException.StatusCode);
}
else
{
SetFatalResponse(StatusCodes.Status500InternalServerError);
}
}
}
finally
{
if (messagePump.DecrementOutstandingRequest() == 0 && messagePump.Stopping)
{
Logger.LogInformation(LoggerEventIds.RequestsDrained, "All requests drained.");
messagePump.SetShutdownSignal();
}
}
}
catch (Exception ex)
{
Logger.LogError(LoggerEventIds.RequestError, ex, "ProcessRequestAsync");
Abort();
}
}
