Comment puis-je sans risque d'interception du flux de la Réponse à une coutume Owin Middleware

Je suis en train d'écrire une simple OWIN Middleware, afin d'intercepter le flux de réponse. Ce que j'essaie de faire est de remplacer le flux d'origine avec personnalisés à partir de Flux de classe, où je serai en mesure d'intercepter écrit dans le flux de réponse.

Cependant, je suis confronté à quelques problèmes parce que je ne peut pas savoir quand la réponse a été entièrement écrite par l'intérieur des composants intergiciels dans la chaîne. Le Dispose de remplacer le Flux n'est jamais appelée. Donc, je ne sais pas quand il est temps de faire mon traitement, ce qui devrait arriver à la fin du Flux de réponse.

Voici un exemple de code:

public sealed class CustomMiddleware: OwinMiddleware
{
public CustomMiddleware(OwinMiddleware next)
: base(next)
{
}
public override async Task Invoke(IOwinContext context)
{
var request = context.Request;
var response = context.Response;
//capture response stream
var vr = new MemoryStream();
var responseStream = new ResponseStream(vr, response.Body);
response.OnSendingHeaders(state =>
{
var resp = (state as IOwinContext).Response;
var contentLength = resp.Headers.ContentLength;
//contentLength == null for Chunked responses
}, context);
//invoke the next middleware in the pipeline
await Next.Invoke(context);
}
}
public sealed class ResponseStream : Stream
{
private readonly Stream stream_; //MemoryStream
private readonly Stream output_; //Owin response
private long writtenBytes_ = 0L;
public ResponseStream(Stream stream, Stream output)
{
stream_ = stream;
output_ = output;
}
... //System.IO.Stream implementation
public override void Write(byte[] buffer, int offset, int count)
{
//capture writes to the response stream in our local stream
stream_.Write(buffer, offset, count);
//write to the real output stream
output_.Write(buffer, offset, count);
//update the number of bytes written
writtenBytes_ += count;
//how do we know the response is complete ?
//we could check that the number of bytes written
//is equal to the content length, but content length
//is not available for Chunked responses.
}
protected override void Dispose(bool disposing)
{
//we could perform our processing
//when the stream is disposed of.
//however, this method is never called by
//the OWIN/Katana infrastructure.
}
}

Comme je l'ai déjà évoqué dans les commentaires du code ci-dessus, il y a deux stratégies que je pense, afin de détecter si la réponse est complète.

a) je peux enregistrer le nombre d'octets écrits dans le flux de réponse et de corréler que la longueur de la réponse. Toutefois, dans le cas de réponses qui utilisent l'Encodage de Transfert en Bloc, la durée n'est pas connue.

b) je peux décider que le flux de réponse est complète lorsque Dispose est appelée sur le flux de réponse. Cependant, la OWIN/Katana de l'infrastructure n'appelle jamais Céder sur l'remplacé flux.

J'ai étudié Opaque En Streaming afin de voir si la manipulation de la sous-jacentes HTTP protocole de serait une approche possible, mais je ne semble pas trouver si Katana support Opaque en Streaming ou pas.

Est-il un moyen de réaliser ce que je veux ?

InformationsquelleAutor Maxime Labelle | 2014-10-06
  1. 36

    Je ne pense pas que vous aurez besoin d'un sous-classés flux, mais puis ici, c'est la façon dont vous pouvez lire la réponse. Assurez-vous juste de ce middleware est le premier dans la OWIN pipeline de sorte qu'il sera le dernier à inspecter la réponse.

    using AppFunc = Func<IDictionary<string, object>, Task>;
public class CustomMiddleware
{
private readonly AppFunc next;
public CustomMiddleware(AppFunc next)
{
this.next = next;
}
public async Task Invoke(IDictionary<string, object> env)
{
IOwinContext context = new OwinContext(env);
//Buffer the response
var stream = context.Response.Body;
var buffer = new MemoryStream();
context.Response.Body = buffer;
await this.next(env);
buffer.Seek(0, SeekOrigin.Begin);
var reader = new StreamReader(buffer);
string responseBody = await reader.ReadToEndAsync();
//Now, you can access response body.
Debug.WriteLine(responseBody);
//You need to do this so that the response we buffered
//is flushed out to the client application.
buffer.Seek(0, SeekOrigin.Begin);
await buffer.CopyToAsync(stream);
}
}

    BTW, autant que je sache, découlant de OwinMiddleware n'est pas considéré comme une bonne pratique car OwinMiddleware est spécifique à Katana. Il est cependant rien à voir avec votre problème.

    • Merci pour votre réponse. Point pris sur dérivant de OwinMiddleware. Cependant, dans votre réponse, vous êtes à l'aide OwinContext qui est également spécifique à Katana. Ai-je raté quelque chose ?
    • Oui, vous avez raison. Mais je suis en utilisant OwinContext en interne pour le middleware, ce qui signifie que je vais prendre une dépendance sur le Katana. Cependant, en n'utilisant pas dans le constructeur ou Invoke signatures de méthode, je ne force pas les autres assemblées de prendre une dépendance sur Katana. Celui qui construit le OWIN pipeline n'a pas besoin de savoir quelque chose au sujet de OwinMiddleware. De même, lorsqu'un middleware avant cette dans le pipeline appels Invoke.
    • J'ai réussi à trouver un lien vers une réponse de David Fowler lié à ce. stackoverflow.com/a/19613529/1709870
    • Étrange, la réponse est juste, est simple, mais je ne pouvais pas le faire fonctionner à tous: stackoverflow.com/questions/29884776/...
    • Pourquoi ne pas le Flux éliminés avec un Using? Je vois cela dans la plupart des middleware de Réponse\Demande de Messages.. c'Est juste parce qu'elle est connue, la durée de vie du middleware est court?
    InformationsquelleAutor Badri