protected override async Task ProcessAsync(HttpContext context, bool useMinification, bool useCompression)
{
IFeatureCollection features = context.Features;
IHttpResponseBodyFeature originalBodyFeature = features.Get <IHttpResponseBodyFeature>();
var bodyWrapperStream = new BodyWrapperStreamWithResponseBodyFeature(context, _options,
useMinification ? _minificationManagers : new List <IMarkupMinificationManager>(),
useCompression ? _compressionManager : null,
originalBodyFeature);
features.Set <IHttpResponseBodyFeature>(bodyWrapperStream);
try
{
await _next(context);
await bodyWrapperStream.FinishAsync();
}
finally
{
await bodyWrapperStream.DisposeAsync();
features.Set(originalBodyFeature);
}
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
app.Use(async(ctx, next) =>
{
IHttpResponseBodyFeature f = ctx.Features.Get <IHttpResponseBodyFeature>();
f?.DisableBuffering();
await next();
});
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
app.UseHttpsRedirection();
app.UseRouting();
app.UseAuthorization();
app.UseEndpoints(endpoints =>
{
endpoints.MapControllers();
endpoints.MapODataRoute("test", "test", GetModel());
});
}
public GrpcWebFeature(ServerGrpcWebMode grpcWebMode, HttpContext httpContext)
{
// Capture existing features. We'll use these internally, and restore them onto the context
// once the middleware has finished executing.
// Note that some of these will be missing depending on the host and protocol.
// e.g.
// - IHttpResponseTrailersFeature and IHttpResetFeature will be missing when HTTP/1.1.
// - IRequestBodyPipeFeature will be missing when in IIS.
_initialRequestFeature = httpContext.Features.Get <IRequestBodyPipeFeature>();
_initialResponseFeature = GetRequiredFeature <IHttpResponseBodyFeature>(httpContext);
_initialResetFeature = httpContext.Features.Get <IHttpResetFeature>();
_initialTrailersFeature = httpContext.Features.Get <IHttpResponseTrailersFeature>();
var innerReader = _initialRequestFeature?.Reader ?? httpContext.Request.BodyReader;
var innerWriter = _initialResponseFeature.Writer ?? httpContext.Response.BodyWriter;
Trailers = new HeaderDictionary();
if (grpcWebMode == ServerGrpcWebMode.GrpcWebText)
{
Reader = new Base64PipeReader(innerReader);
Writer = new Base64PipeWriter(innerWriter);
}
else
{
Reader = innerReader;
Writer = innerWriter;
}
httpContext.Features.Set <IRequestBodyPipeFeature>(this);
httpContext.Features.Set <IHttpResponseBodyFeature>(this);
httpContext.Features.Set <IHttpResponseTrailersFeature>(this);
httpContext.Features.Set <IHttpResetFeature>(this);
}
/// <summary>
/// Constructs an instance of the stream wrapper with HTTP response body feature
/// </summary>
/// <param name="context">HTTP context</param>
/// <param name="options">WebMarkupMin configuration</param>
/// <param name="minificationManagers">List of markup minification managers</param>
/// <param name="compressionManager">HTTP compression manager</param>
/// <param name="responseBodyFeature">HTTP response body feature</param>
internal BodyWrapperStreamWithResponseBodyFeature(HttpContext context,
WebMarkupMinOptions options, IList <IMarkupMinificationManager> minificationManagers,
IHttpCompressionManager compressionManager, IHttpResponseBodyFeature responseBodyFeature)
: base(context, responseBodyFeature.Stream, options, minificationManagers, compressionManager)
{
_responseBodyFeature = responseBodyFeature;
}
public BodyRedirector(HttpContext context, Pipe requestPipe, Pipe responsePipe)
{
// gRPC middleware don't flush so we have to flush for them
// This means we need access to their pipe writer, so we switch the body pipe features as well to get raw access
// Although it seems like we could instead switch the body pipe properties on the request and the response
// as documented by https://docs.microsoft.com/en-us/aspnet/core/fundamentals/middleware/request-response?view=aspnetcore-3.0#adapters
// this ability was removed in https://github.com/aspnet/AspNetCore/pull/10154
_context = context;
_requestBody = _context.Request.Body;
_context.Request.Body = requestPipe.Reader.AsStream(true);
_requestBodyPipe = _context.Features.Get <IRequestBodyPipeFeature>();
_context.Features.Set <IRequestBodyPipeFeature>(
new RequestBodyPipeFeature {
Reader = requestPipe.Reader
});
_responseBody = _context.Features.Get <IHttpResponseBodyFeature>();
var responseBody = new ResponseBodyFeature(_responseBody)
{
Writer = responsePipe.Writer
};
_context.Features.Set <IHttpResponseBodyFeature>(responseBody);
}
public CaptureHttpResponseBodyFeature(IHttpResponseBodyFeature responseBodyFeature)
{
_responseBodyFeature = responseBodyFeature;
_capturedDataStream = new MemoryStream();
_captureStream = new DataCaptureStream(responseBodyFeature.Stream, _capturedDataStream);
_capturePipeWriter = new CapturePipeWriter(responseBodyFeature.Writer, _capturedDataStream);
}
public UsageResponseBodyFeature(IHttpResponseBodyFeature inner)
{
usageStream = new UsageStream(inner.Stream);
usageWriter = new UsagePipeWriter(inner.Writer);
this.inner = inner;
}
internal ResponseCompressionBody(HttpContext context, IResponseCompressionProvider provider,
IHttpResponseBodyFeature innerBodyFeature)
{
_context = context;
_provider = provider;
_innerBodyFeature = innerBodyFeature;
_innerStream = innerBodyFeature.Stream;
}
private static void DisableResponseBuffering(HttpContext context)
{
IHttpResponseBodyFeature responseBodyFeature = context.Features.Get <IHttpResponseBodyFeature>();
if (responseBodyFeature != null)
{
responseBodyFeature.DisableBuffering();
}
}
public StreamResponseBodyFeature(Stream stream, IHttpResponseBodyFeature priorFeature)
{
Stream stream1 = stream;
if (stream1 == null)
{
throw new ArgumentNullException(nameof(stream));
}
this.Stream = stream1;
this.PriorFeature = priorFeature;
}
public GrpcProxy(HttpContext context)
{
_context = context;
_originalProtocol = context.Request.Protocol;
_originalRequestBodyPipeFeature = context.Features.Get <IRequestBodyPipeFeature>() !;
_originalResponseBodyFeature = context.Features.Get <IHttpResponseBodyFeature>() !;
_originalResponseTrailersFeature = context.Features.Get <IHttpResponseTrailersFeature>();
_responseStream = new MemoryStream();
Trailers = new HeaderDictionary();
}
/// <summary>
/// Disables MVC Buffering
/// </summary>
private void DisableBuffering()
{
if (_context == null)
{
return;
}
IHttpResponseBodyFeature responseBodyFeature = _context.HttpContext.Features.Get <IHttpResponseBodyFeature>();
if (responseBodyFeature != null)
{
responseBodyFeature.DisableBuffering();
}
}
private ActionContext PrepareActionContext(IHttpResponseBodyFeature httpResponseBodyFeature = null)
{
HttpContext httpContext = new DefaultHttpContext();
if (httpResponseBodyFeature != null)
{
httpContext.Features.Set(httpResponseBodyFeature);
}
return(new ActionContext(
httpContext,
new RouteData(),
new ActionDescriptor()
));
}
internal ResponseBufferingStream(IHttpResponseBodyFeature innerBodyFeature,
int limit,
ILogger logger,
HttpContext context,
List <MediaTypeState> encodings,
HttpLoggingOptions options)
: base(innerBodyFeature.Stream, logger)
{
_innerBodyFeature = innerBodyFeature;
_innerStream = innerBodyFeature.Stream;
_limit = limit;
_context = context;
_encodings = encodings;
_options = options;
}
public override Task ExecuteResultAsync(ActionContext context)
{
Microsoft.AspNetCore.Http.HttpResponse response = context.HttpContext.Response;
response.ContentType = ResultContentType;
System.IO.Stream stream = response.Body;
IHttpResponseBodyFeature bufferingFeature = context.HttpContext.Features.Get <IHttpResponseBodyFeature>();
if (bufferingFeature != null)
{
bufferingFeature.DisableBuffering();
}
return(_serializer.SerializeAsync <T>(Data, stream));
}
private static void DisableResponseBuffering(HttpContext context)
{
IHttpResponseBodyFeature bufferingFeature = context.Features.Get <IHttpResponseBodyFeature>();
if (bufferingFeature != null)
{
bufferingFeature.DisableBuffering();
}
//.NET Core 2.2
//IHttpBufferingFeature bufferingFeature = context.Features.Get<IHttpBufferingFeature>();
//if (bufferingFeature != null)
//{
// bufferingFeature.DisableResponseBuffering();
//}
}
private void DisableResponseBuffering(HttpContext context)
{
#if !NETCOREAPP2_1 && !NET461
IHttpResponseBodyFeature responseBodyFeature = context.Features.Get <IHttpResponseBodyFeature>();
if (responseBodyFeature != null)
{
responseBodyFeature.DisableBuffering();
}
#else
IHttpBufferingFeature bufferingFeature = context.Features.Get <IHttpBufferingFeature>();
if (bufferingFeature != null)
{
bufferingFeature.DisableResponseBuffering();
}
#endif
}
public async Task ProcessRequestAsync(IFeatureCollection features)
{
bool emptyBody = false;
IHttpRequestFeature request = (IHttpRequestFeature)features[typeof(IHttpRequestFeature)];
IHttpResponseFeature response = (IHttpResponseFeature)features[typeof(IHttpResponseFeature)];
IHttpResponseBodyFeature responseBody = (IHttpResponseBodyFeature)features[typeof(IHttpResponseBodyFeature)];
Dictionary <string, object> jsonObjects = new Dictionary <string, object>();
// This uses reflection
// jsonObjects = await JsonSerializer.DeserializeAsync<Dictionary<string, object>>(request.Body);
// This has internal Assembly call
// JsonSerializerOptions serializerOptions = new JsonSerializerOptions();
// serializerOptions.Converters.Add(new NativeJson());
// jsonObjects = await JsonSerializer.DeserializeAsync<Dictionary<string, object>>(request.Body, serializerOptions);
// More complex
// NativeJson.Read(request.Body);
try
{
using (StreamReader streamReader = new StreamReader(request.Body))
{
//string requestBodyString = await streamReader.ReadToEndAsync();
//byte[] utf8JsonBytes = Encoding.UTF8.GetBytes(requestBodyString);
//Utf8JsonReader utf8JsonReader = new Utf8JsonReader(utf8JsonBytes);
using (JsonDocument document = await JsonDocument.ParseAsync(streamReader.BaseStream))
{
JsonElement root = document.RootElement;
if (root.ValueKind == JsonValueKind.Object)
{
foreach (JsonProperty property in root.EnumerateObject())
{
jsonObjects.Add(property.Name, property.Value.ToString());
}
jsonObjects.Add("feedback", "your json has just gone through a native kestrel");
}
else if (root.ValueKind == JsonValueKind.Array)
{
foreach (JsonElement element in root.EnumerateArray())
{
}
}
}
}
}
catch
{
emptyBody = true;
}
if (emptyBody)
{
jsonObjects.Add("firstname", "Natty");
jsonObjects.Add("lastname", "de Balancet");
jsonObjects.Add("info", "copy this json and post it back");
}
JsonWriterOptions jsonWriterOptions = new JsonWriterOptions
{
Indented = true
};
MemoryStream memoryStream = new MemoryStream();
using (Utf8JsonWriter utf8JsonWriter = new Utf8JsonWriter(memoryStream, jsonWriterOptions))
{
utf8JsonWriter.WriteStartObject();
foreach (KeyValuePair <string, object> keyValuePair in jsonObjects)
{
utf8JsonWriter.WriteString(keyValuePair.Key, keyValuePair.Value.ToString());
//utf8JsonWriter.WriteNumber("temp", 42);
}
utf8JsonWriter.WriteEndObject();
utf8JsonWriter.Flush();
//string responseString = Encoding.UTF8.GetString(memoryStream.ToArray());
}
/* Database call test
* string names = string.Empty;
*
* //Odbc pool test
* for (int i = 0; i < 2; i++)
* {
* using (IDbConnection dbConnection = new NativeConnection())
* {
* names = OdbcPerformance.ReadContacts(dbConnection);
* }
* }
*
* jsonObjects.Add("names", names);
*/
//byte[] responseBodyBytes = Encoding.UTF8.GetBytes(responseString);
response.Headers.ContentLength = memoryStream.Length; //responseBodyBytes.Length;
response.Headers.Add("Content-Type", "application/json");
await responseBody.Stream.WriteAsync(memoryStream.ToArray(), 0, (int)memoryStream.Length);
}
/// <summary>
/// Wraps the given stream and tracks the prior feature instance.
/// </summary>
/// <param name="stream"></param>
/// <param name="priorFeature"></param>
public StreamResponseBodyFeature(Stream stream, IHttpResponseBodyFeature priorFeature)
{
Stream = stream ?? throw new ArgumentNullException(nameof(stream));
PriorFeature = priorFeature;
}
private async Task <HttpResponse> GetResponseAsync(HttpResponseMessage response, IHttpResponseBodyFeature httpResponseBodyFeature)
{
ProxyHeaders(httpContextAccessor.HttpContext.Response, response);
httpContextAccessor.HttpContext.Response.StatusCode = (int)response.StatusCode;
await httpResponseBodyFeature.StartAsync();
await ProxyBodyAsync(httpContextAccessor.HttpContext.Response, response);
return(httpContextAccessor.HttpContext.Response);
}
public virtual async Task <HttpResponse> ProcessResponseAsync(HttpResponseMessage response, IHttpResponseBodyFeature httpResponseBodyFeature)
{
return(await GetResponseAsync(response, httpResponseBodyFeature));
}
public InnerDisableBufferingFeature(Stream stream, IHttpResponseBodyFeature priorFeature)
: base(stream, priorFeature)
{
}
public ResponseBodyFeature(IHttpResponseBodyFeature priorFeature)
{
_priorFeature = priorFeature;
}
public TestHttpResponseBodyFeature(IHttpResponseBodyFeature innerResponseBodyFeature, TestHttpResponseFeature responseFeature, Func <Task>?completeAsyncAction = null)
{
_innerResponseBodyFeature = innerResponseBodyFeature ?? throw new ArgumentNullException(nameof(innerResponseBodyFeature));
_responseFeature = responseFeature ?? throw new ArgumentNullException(nameof(responseFeature));
_completeAsyncAction = completeAsyncAction;
}
public TestHttpResponseBodyFeature(IHttpResponseBodyFeature innerResponseBodyFeature, TestHttpResponseFeature responseFeature)
{
_innerResponseBodyFeature = innerResponseBodyFeature ?? throw new ArgumentNullException(nameof(innerResponseBodyFeature));
_responseFeature = responseFeature ?? throw new ArgumentNullException(nameof(responseFeature));
}
