public async ValueTask <IDispatchResult> HandleAsync(ModuleHttpRequest request, CancellationToken cancellation)
{
if (_server == null || !(_server is IModuleServer moduleServer))
{
return(DispatchFailure());
}
var httpRequestExecutor = moduleServer.RequestExecutor;
// The server is not yet started or is disposed.
if (httpRequestExecutor == null)
{
return(DispatchFailure());
}
var response = await httpRequestExecutor.ExecuteAsync(request, cancellation);
// This is a special case that should be respected in order to invoke the next http module handler
// or the next pipeline step in the senders http request pipeline.
if (response.StatusCode == 404)
{
return(DispatchFailure());
}
return(Success(response));
}
public async ValueTask <ModuleHttpResponse> ExecuteAsync(ModuleHttpRequest request, CancellationToken cancellation)
{
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
var requestMessage = request;
var responseStream = new MemoryStream();
var requestFeature = BuildRequestFeature(requestMessage);
var responseFeature = BuildResponseFeature(responseStream);
var features = BuildFeatureCollection(requestFeature, responseFeature);
var context = _application.CreateContext(features);
try
{
await _application.ProcessRequestAsync(context);
var responseMessage = BuildResponseMessage(responseStream, responseFeature);
ExceptionHelper.HandleExceptions(() => _application.DisposeContext(context, exception: null), _logger);
return(responseMessage);
}
catch (Exception exc)
{
ExceptionHelper.HandleExceptions(() => _application.DisposeContext(context, exc), _logger);
throw;
}
}
private static HttpRequestFeature BuildRequestFeature(ModuleHttpRequest message)
{
var requestFeature = new HttpRequestFeature
{
Method = message.Method,
Path = message.Path,
PathBase = message.PathBase,
Protocol = message.Protocol,
QueryString = message.QueryString,
RawTarget = message.RawTarget,
Scheme = message.Scheme,
Body = new MemoryStream(message.Body),
Headers = new HeaderDictionary()
};
foreach (var header in message.Headers)
{
requestFeature.Headers.Add(header.Key, new StringValues(header.Value));
}
return(requestFeature);
}
private static async Task <ModuleHttpRequest> PackRequestMessage(HttpContext context)
{
var requestFeature = GetRequestFeature(context);
var result = new ModuleHttpRequest
{
Method = requestFeature.Method,
Path = requestFeature.Path,
PathBase = requestFeature.PathBase,
Protocol = requestFeature.Protocol,
QueryString = requestFeature.QueryString,
RawTarget = requestFeature.RawTarget,
Scheme = requestFeature.Scheme,
Body = requestFeature.Body == null?Array.Empty <byte>() : await requestFeature.Body.ToArrayAsync(),
Headers = new Dictionary <string, string[]>()
};
foreach (var entry in requestFeature.Headers)
{
result.Headers.Add(entry.Key, entry.Value.ToArray());
}
return(result);
}
private async Task <IDispatchResult> DispatchToEndPointAsync(EndPointAddress endPoint, ModuleHttpRequest moduleHttpRequest, CancellationToken cancellation)
{
return(await _dispatcher.DispatchAsync(new DispatchDataDictionary <ModuleHttpRequest>(moduleHttpRequest), publish : false, endPoint, cancellation));
}
