internal RequestState(IHttpRequestFeature requestFeature, IHttpContextFactory factory,
IFeatureCollection featureCollection)
{
_factory = factory;
_requestAbortedSource = new CancellationTokenSource();
_pipelineFinished = false;
var contextFeatures = new FeatureCollection(featureCollection);
contextFeatures.Set(requestFeature);
_responseStream = new WriteOnlyResponseStream(AbortRequest);
_responseFeature = new ResponseFeature(requestFeature.Protocol, 200, null, _responseStream, new HeaderDictionary())
{
Abort = Abort
};
contextFeatures.Set <IHttpResponseFeature>(_responseFeature);
contextFeatures.Set <IHttpResponseBodyFeature>(new StreamResponseBodyFeature(_responseStream));
var requestLifetimeFeature = new HttpRequestLifetimeFeature();
contextFeatures.Set <IHttpRequestLifetimeFeature>(requestLifetimeFeature);
requestLifetimeFeature.RequestAborted = _requestAbortedSource.Token;
Context = _factory.Create(contextFeatures);
}
internal RequestState(IHttpRequestFeature requestFeature, IHttpContextFactory factory,
IFeatureCollection featureCollection)
{
_factory = factory;
_requestAbortedSource = new CancellationTokenSource();
_pipelineFinished = false;
var contextFeatures = new FeatureCollection(featureCollection);
contextFeatures.Set(requestFeature);
_responseFeature = new ResponseFeature {
Protocol = requestFeature.Protocol
};
contextFeatures.Set <IHttpResponseFeature>(_responseFeature);
var requestLifetimeFeature = new HttpRequestLifetimeFeature();
contextFeatures.Set <IHttpRequestLifetimeFeature>(requestLifetimeFeature);
_responseStream = new WriteOnlyResponseStream(AbortRequest);
_responseFeature.Body = _responseStream;
_responseFeature.StatusCode = 200;
requestLifetimeFeature.RequestAborted = _requestAbortedSource.Token;
Context = _factory.Create(contextFeatures);
}
internal HttpContextBuilder(IHttpApplication <HostingApplication.Context> application)
{
_application = application ?? throw new ArgumentNullException(nameof(application));
_httpContext = new DefaultHttpContext();
var request = _httpContext.Request;
request.Protocol = "HTTP/1.1";
request.Method = HttpMethods.Get;
_httpContext.Features.Set <IHttpResponseFeature>(_responseFeature);
var requestLifetimeFeature = new HttpRequestLifetimeFeature();
requestLifetimeFeature.RequestAborted = _requestAbortedSource.Token;
_httpContext.Features.Set <IHttpRequestLifetimeFeature>(requestLifetimeFeature);
_responseStream = new ResponseStream(ReturnResponseMessageAsync, AbortRequest);
_responseFeature.Body = _responseStream;
}
private async ValueTask <ResponseMessage> ProgressPipeline(
HttpContext context,
RequestDelegate next,
RequestMessage requestMessage,
ResponseMessage responseMessage,
CancellationToken cancellationToken
)
{
var requestFeature = new RequestFeature(requestMessage);
var responseFeature = new ResponseFeature(responseMessage);
var requestLifetimeFeature = new HttpRequestLifetimeFeature
{
RequestAborted = cancellationToken
};
var serviceProviderFeature = context.Features.Get <IServiceProvidersFeature>();
var requestAuthenticationFeature = context.Features.Get <IHttpAuthenticationFeature>();
var formFeature = context.Features.Get <IFormFeature>();
var responseTrailersFeature = context.Features.Get <IHttpResponseTrailersFeature>();
//var httpResponseBodyFeature = context.Features.Get<IHttpResponseBodyFeature>();
//var httpBodyControlFeature = context.Features.Get<IHttpResponseBodyPipeFeature>();
//var httpResponseBodyFeature = context.Features.Get<IHttpResponseFeature>();
GC.KeepAlive(context.Features);
var features = new FeatureCollection();
features.Set <IHttpRequestFeature>(new HttpRequestFeature());
features.Set <IHttpResponseFeature>(new HttpResponseFeature());
// features.Set<IHttpRequestFeature>(requestFeature);
// features.Set<IHttpResponseFeature>(responseFeature);
features.Set <IHttpRequestLifetimeFeature>(requestLifetimeFeature);
features.Set <IHttpAuthenticationFeature>(requestAuthenticationFeature);
features.Set <IServiceProvidersFeature>(serviceProviderFeature);
features.Set <IFormFeature>(formFeature);
features.Set <IHttpResponseTrailersFeature>(responseTrailersFeature);
//features.Set<IHttpBodyControlFeature>(httpBodyControlFeature);
//features.Set<IHttpResponseBodyFeature>(httpResponseBodyFeature);
//features.Set<IHttpResponseBodyPipeFeature>(null);
var ctx = new DefaultHttpContext(features);
await MessageConverter.CopyRequestMessageToTarget(ctx.Request, requestMessage, cancellationToken);
IServiceProvider serviceProvider;
if (Configuration.InProcessScopeMode != RedTransportInProcessScopeMode.UseRootScope)
{
//creating a new scope for IServiceProvider.
var factory = serviceProviderFeature.RequestServices.GetRequiredService <IServiceScopeFactory>();
serviceProvider = factory.CreateScope().ServiceProvider;
serviceProviderFeature = new ServiceProvidersFeature
{
RequestServices = serviceProvider
};
features.Set <IServiceProvidersFeature>(serviceProviderFeature);
}
else
{
serviceProvider = serviceProviderFeature.RequestServices;
}
var memStream = new MemoryStream();
ctx.Response.Body = memStream;
//GC.KeepAlive(ctx.Response.Body);
ctx.Response.RegisterForDispose(memStream);
await next(ctx);
return(await MessageConverter.FromResponseAsync(ctx.Response, cancellationToken));
}
internal RequestState(HttpRequestMessage request, PathString pathBase, IHttpApplication <Context> application)
{
_request = request;
_application = application;
_responseTcs = new TaskCompletionSource <HttpResponseMessage>();
_requestAbortedSource = new CancellationTokenSource();
_pipelineFinished = false;
if (request.RequestUri.IsDefaultPort)
{
request.Headers.Host = request.RequestUri.Host;
}
else
{
request.Headers.Host = request.RequestUri.GetComponents(UriComponents.HostAndPort, UriFormat.UriEscaped);
}
var contextFeatures = new FeatureCollection();
var requestFeature = new RequestFeature();
contextFeatures.Set <IHttpRequestFeature>(requestFeature);
_responseFeature = new ResponseFeature();
contextFeatures.Set <IHttpResponseFeature>(_responseFeature);
var requestLifetimeFeature = new HttpRequestLifetimeFeature();
contextFeatures.Set <IHttpRequestLifetimeFeature>(requestLifetimeFeature);
requestFeature.Protocol = "HTTP/" + request.Version.ToString(fieldCount: 2);
requestFeature.Scheme = request.RequestUri.Scheme;
requestFeature.Method = request.Method.ToString();
var fullPath = PathString.FromUriComponent(request.RequestUri);
PathString remainder;
if (fullPath.StartsWithSegments(pathBase, out remainder))
{
requestFeature.PathBase = pathBase.Value;
requestFeature.Path = remainder.Value;
}
else
{
requestFeature.PathBase = string.Empty;
requestFeature.Path = fullPath.Value;
}
requestFeature.QueryString = QueryString.FromUriComponent(request.RequestUri).Value;
foreach (var header in request.Headers)
{
requestFeature.Headers.Append(header.Key, header.Value.ToArray());
}
var requestContent = request.Content;
if (requestContent != null)
{
foreach (var header in request.Content.Headers)
{
requestFeature.Headers.Append(header.Key, header.Value.ToArray());
}
}
_responseStream = new ResponseStream(ReturnResponseMessageAsync, AbortRequest);
_responseFeature.Body = _responseStream;
_responseFeature.StatusCode = 200;
requestLifetimeFeature.RequestAborted = _requestAbortedSource.Token;
Context = application.CreateContext(contextFeatures);
}
