Подтвердить что ты не робот

Как включить веб-API.Net для приема сообщений g-ziped

У меня есть довольно стандартное приложение .net MVC 4 Web API.

 public class LogsController : ApiController
{

    public HttpResponseMessage PostLog(List<LogDto> logs)
    {
        if (logs != null && logs.Any())
        {
            var goodLogs = new List<Log>();
            var badLogs = new List<LogBad>();

            foreach (var logDto in logs)
            {
                if (logDto.IsValid())
                {
                    goodLogs.Add(logDto.ToLog());
                }
                else
                {
                    badLogs.Add(logDto.ToLogBad());
                }
            }

            if (goodLogs.Any())
            {
                _logsRepo.Save(goodLogs);
            }

            if(badLogs.Any())
            {
                _logsBadRepo.Save(badLogs);
            }


        }
        return new HttpResponseMessage(HttpStatusCode.OK);
    }
}

Все это прекрасно работает, у меня есть устройства, которые могут отправлять мне свои журналы, и это работает хорошо. Однако теперь мы начинаем беспокоиться о размере передаваемых данных, и мы хотим взглянуть на прием сообщения, сжатого с использованием GZIP?

Как мне это сделать? Является ли он настройкой в ​​IIS или я могу использовать пользовательские фильтры действий?

РЕДАКТИРОВАТЬ 1

Следуя примеру Филиппа, я думаю, что мне нужно перехватить обработку запроса до того, как он попадет на мой контроллер. Если я могу уловить запрос до того, как веб-api framework попытается проанализировать тело запроса в моем бизнес-объекте, что не получается, потому что тело запроса все еще сжато. Затем я могу распаковать тело запроса, а затем передать запрос обратно в цепочку обработки, и, надеюсь, структура Web Api сможет анализировать (распаковывать) тело на мои бизнес-объекты.

Похоже, что использование DelagatingHandler - путь. Это позволяет мне получить доступ к запросу во время обработки, но до моего контроллера. Итак, я попробовал следующее:

 public class gZipHandler : DelegatingHandler
{

    protected override System.Threading.Tasks.Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, System.Threading.CancellationToken cancellationToken)
    {
        string encodingType = request.Headers.AcceptEncoding.First().Value;

        request.Content = new DeCompressedContent(request.Content, encodingType);

        return base.SendAsync(request, cancellationToken);
    }
}

public class DeCompressedContent : HttpContent
{
    private HttpContent originalContent;
    private string encodingType;

    public DeCompressedContent(HttpContent content, string encodType)
    {
        originalContent = content;
        encodingType = encodType;
    }

    protected override bool TryComputeLength(out long length)
    {
        length = -1;

        return false;
    }


    protected override Task<Stream> CreateContentReadStreamAsync()
    {
        return base.CreateContentReadStreamAsync();
    }

    protected override Task SerializeToStreamAsync(Stream stream, TransportContext context)
    {
        Stream compressedStream = null;

        if (encodingType == "gzip")
        {
            compressedStream = new GZipStream(stream, CompressionMode.Decompress, leaveOpen: true);
        }

        return originalContent.CopyToAsync(compressedStream).ContinueWith(tsk =>
        {
            if (compressedStream != null)
            {
                compressedStream.Dispose();
            }
        });
    }



}

}

Кажется, это работает нормально. Метод SendAsync вызывается перед моим контроллером и вызывается конструктор для DecompressedContent. Однако SerializeToStreamAsync никогда не вызывается, поэтому я добавил CreateContentReadStreamAsync, чтобы узнать, должно ли происходить декомпрессия, но это не вызвано.

Я упал, как будто я близок к решению, но мне нужно немного больше, чтобы получить его над линией.

4b9b3361

Ответ 1

У меня было такое же требование, что и данные POST gzipped для .NET-api-контроллера. Я придумал это решение:

public class GZipToJsonHandler : DelegatingHandler
{
    protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request,
                                                           CancellationToken cancellationToken)
    {
        // Handle only if content type is 'application/gzip'
        if (request.Content.Headers.ContentType == null ||
            request.Content.Headers.ContentType.MediaType != "application/gzip")
        {
            return base.SendAsync(request, cancellationToken);
        }

        // Read in the input stream, then decompress in to the outputstream.
        // Doing this asynronously, but not really required at this point
        // since we end up waiting on it right after this.
        Stream outputStream = new MemoryStream();
        Task task = request.Content.ReadAsStreamAsync().ContinueWith(t =>
            {
                Stream inputStream = t.Result;
                var gzipStream = new GZipStream(inputStream, CompressionMode.Decompress);

                gzipStream.CopyTo(outputStream);
                gzipStream.Dispose();

                outputStream.Seek(0, SeekOrigin.Begin);
            });

        // Wait for inputstream and decompression to complete. Would be nice
        // to not block here and work async when ready instead, but I couldn't 
        // figure out how to do it in context of a DelegatingHandler.
        task.Wait();

        // This next section is the key...

        // Save the original content
        HttpContent origContent = request.Content;

        // Replace request content with the newly decompressed stream
        request.Content = new StreamContent(outputStream);

        // Copy all headers from original content in to new one
        foreach (var header in origContent.Headers)
        {
            request.Content.Headers.Add(header.Key, header.Value);
        }

        // Replace the original content-type with content type
        // of decompressed data. In our case, we can assume application/json. A
        // more generic and reuseable handler would need some other 
        // way to differentiate the decompressed content type.
        request.Content.Headers.Remove("Content-Type");
        request.Content.Headers.Add("Content-Type", "application/json");

        return base.SendAsync(request, cancellationToken);
    }
}

Используя этот подход, существующий контроллер, который обычно работает с содержимым JSON и автоматической привязкой к модели, продолжает работать без каких-либо изменений.

Я не знаю, почему был принят другой ответ. Он предоставляет решение для обработки ответов (что является общим), но не запросов (что является необычным). Заголовок Accept-Encoding используется для указания допустимых кодировок ответов и не связан с кодировками запросов.

Ответ 2

Я считаю, что правильным ответом является Kaliatech, и я бы оставил это в качестве комментария и проголосовал за него, у меня было достаточно очков репутации, так как я думаю, что он в основном правильный.

Однако моя ситуация требовала взглянуть на тип типа кодировки, а не на тип содержимого. Используя этот подход, вызывающая система все еще может указать, что тип содержимого - это json/xml/etc в типе контента, но укажите, что данные кодируются с использованием gzip или потенциально другого механизма кодирования/сжатия. Это помешало мне изменить тип содержимого после декодирования ввода и разрешить любую информацию типа содержимого в исходном состоянии.

Вот код. Опять же, 99% из этого - ответ Kaliatech, включая комментарии, поэтому, пожалуйста, проголосуйте за его сообщение, если это полезно.

public class CompressedRequestHandler : DelegatingHandler
{
    protected override System.Threading.Tasks.Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, System.Threading.CancellationToken cancellationToken)
    {
        if (IsRequetCompressed(request))
        {
            request.Content = DecompressRequestContent(request);
        }

        return base.SendAsync(request, cancellationToken);
    }

    private bool IsRequetCompressed(HttpRequestMessage request)
    {
        if (request.Content.Headers.ContentEncoding != null &&
            request.Content.Headers.ContentEncoding.Contains("gzip"))
        {
            return true;
        }

        return false;
    }

    private HttpContent DecompressRequestContent(HttpRequestMessage request)
    {
        // Read in the input stream, then decompress in to the outputstream.
        // Doing this asynronously, but not really required at this point
        // since we end up waiting on it right after this.
        Stream outputStream = new MemoryStream();
        Task task = request.Content.ReadAsStreamAsync().ContinueWith(t =>
            {
                Stream inputStream = t.Result;
                var gzipStream = new GZipStream(inputStream, CompressionMode.Decompress);

                gzipStream.CopyTo(outputStream);
                gzipStream.Dispose();

                outputStream.Seek(0, SeekOrigin.Begin);
            });

        // Wait for inputstream and decompression to complete. Would be nice
        // to not block here and work async when ready instead, but I couldn't 
        // figure out how to do it in context of a DelegatingHandler.
        task.Wait();

        // Save the original content
        HttpContent origContent = request.Content;

        // Replace request content with the newly decompressed stream
        HttpContent newContent = new StreamContent(outputStream);

        // Copy all headers from original content in to new one
        foreach (var header in origContent.Headers)
        {
            newContent.Headers.Add(header.Key, header.Value);
        }

        return newContent;
    }

Затем я зарегистрировал этот обработчик по всему миру, что может быть рискованным предложением, если вы уязвимы для DoS-атак, но наш сервис заблокирован, поэтому он работает для нас

GlobalConfiguration.Configuration.MessageHandlers.Add(new CompressedRequestHandler());

Ответ 3

Хотя веб-API не поддерживает заголовок Accept-Encoding из коробки, но у Kiran есть потрясающее сообщение в блоге о том, как это сделать - http://blogs.msdn.com/b/kiranchalla/archive/2012/09/04/handling-compression-accept-encoding-sample.aspx - используя пользовательский MessageHandler

Если вы реализуете его решение, все, что вам нужно сделать, это выдать запрос с заголовком Accept-Encoding: gzip или Accept-Encoding: deflate, и ответ веб-API будет сжат в обработчике сообщений для вас.

Ответ 4

попробуйте это

    public class DeCompressedContent : HttpContent
{
    private HttpContent originalContent;
    private string encodingType;

    /// <summary>
    /// 
    /// </summary>
    /// <param name="content"></param>
    /// <param name="encodingType"></param>
    public DeCompressedContent(HttpContent content, string encodingType)
    {

        if (content == null) throw new ArgumentNullException("content");
        if (string.IsNullOrWhiteSpace(encodingType)) throw new ArgumentNullException("encodingType");

        this.originalContent = content;
        this.encodingType = encodingType.ToLowerInvariant();

        if (!this.encodingType.Equals("gzip", StringComparison.CurrentCultureIgnoreCase) && !this.encodingType.Equals("deflate", StringComparison.CurrentCultureIgnoreCase))
        {
            throw new InvalidOperationException(string.Format("Encoding {0} is not supported. Only supports gzip or deflate encoding", this.encodingType));
        }

        foreach (KeyValuePair<string, IEnumerable<string>> header in originalContent.Headers)
        {
            this.Headers.TryAddWithoutValidation(header.Key, header.Value);
        }

        this.Headers.ContentEncoding.Add(this.encodingType);
    }

    /// <summary>
    /// 
    /// </summary>
    /// <param name="stream"></param>
    /// <param name="context"></param>
    /// <returns></returns>
    protected override Task SerializeToStreamAsync(Stream stream, TransportContext context)
    {
        var output = new MemoryStream();

        return this.originalContent
            .CopyToAsync(output).ContinueWith(task =>
            {
                // go to start
                output.Seek(0, SeekOrigin.Begin);

                if (this.encodingType.Equals("gzip", StringComparison.CurrentCultureIgnoreCase))
                {
                    using (var dec = new GZipStream(output, CompressionMode.Decompress))
                    {
                        dec.CopyTo(stream);
                    }
                }
                else
                {
                    using (var def = new DeflateStream(output, CompressionMode.Decompress))
                    {
                        def.CopyTo(stream);
                    }
                }

                if (output != null)
                    output.Dispose();
            });


    }

    /// <summary>
    /// 
    /// </summary>
    /// <param name="length"></param>
    /// <returns></returns>
    protected override bool TryComputeLength(out long length)
    {
        length = -1;

        return (false);
    }
}