proxygen: proxygen::ZlibServerFilter Class Reference

#include <ZlibServerFilter.h>

Inheritance diagram for proxygen::ZlibServerFilter:

Public Member Functions
	ZlibServerFilter (RequestHandler *downstream, int32_t compressionLevel, uint32_t minimumCompressionSize, const std::shared_ptr< std::set< std::string >> compressibleContentTypes)

void	sendHeaders (HTTPMessage &msg) noexceptoverride

void	sendChunkHeader (size_t len) noexceptoverride

void	sendBody (std::unique_ptr< folly::IOBuf > body) noexceptoverride

void	sendEOM () noexceptoverride

Public Member Functions inherited from proxygen::Filter
	Filter (RequestHandler *upstream)

void	setResponseHandler (ResponseHandler *handler) noexceptoverride

void	onRequest (std::unique_ptr< HTTPMessage > headers) noexceptoverride

void	onBody (std::unique_ptr< folly::IOBuf > body) noexceptoverride

void	onUpgrade (UpgradeProtocol protocol) noexceptoverride

void	onEOM () noexceptoverride

void	requestComplete () noexceptoverride

void	onError (ProxygenError err) noexceptoverride

void	onEgressPaused () noexceptoverride

void	onEgressResumed () noexceptoverride

bool	canHandleExpect () noexceptoverride

ExMessageHandler *	getExHandler () noexceptoverride

void	sendHeaders (HTTPMessage &msg) noexceptoverride

void	sendChunkHeader (size_t len) noexceptoverride

void	sendBody (std::unique_ptr< folly::IOBuf > body) noexceptoverride

void	sendChunkTerminator () noexceptoverride

void	sendEOM () noexceptoverride

void	sendAbort () noexceptoverride

void	refreshTimeout () noexceptoverride

void	pauseIngress () noexceptoverride

void	resumeIngress () noexceptoverride

ResponseHandler *	newPushedResponse (PushHandler *handler) noexceptoverride

const wangle::TransportInfo &	getSetupTransportInfo () const noexceptoverride

void	getCurrentTransportInfo (wangle::TransportInfo *tinfo) const override

Public Member Functions inherited from proxygen::RequestHandler
virtual ResponseHandler *	getDownstream () noexcept

virtual	~RequestHandler ()

Public Member Functions inherited from proxygen::ResponseHandler
	ResponseHandler (RequestHandler *upstream)

virtual	~ResponseHandler ()

virtual ResponseHandler *	newExMessage (ExMessageHandler *, bool=false) noexcept

HTTPTransaction *	getTransaction () const noexcept

Protected Member Functions
void	fail ()

bool	isMinimumCompressibleSize (const HTTPMessage &msg) const noexcept

bool	isCompressibleContentType (const HTTPMessage &msg) const noexcept

Protected Attributes
std::unique_ptr< HTTPMessage >	responseMessage_

std::unique_ptr< ZlibStreamCompressor >	compressor_ {nullptr}

int32_t	compressionLevel_ {4}

uint32_t	minimumCompressionSize_ {1000}

const std::shared_ptr< std::set< std::string > >	compressibleContentTypes_

bool	header_ {false}

bool	chunked_ {false}

bool	compress_ {false}

Protected Attributes inherited from proxygen::RequestHandler
ResponseHandler *	downstream_ {nullptr}

Protected Attributes inherited from proxygen::ResponseHandler
RequestHandler *	upstream_ {nullptr}

HTTPTransaction *	txn_ {nullptr}

Detailed Description

A Server filter to perform GZip compression. If there are any errors it will fall back to sending uncompressed responses.

Definition at line 25 of file ZlibServerFilter.h.

Constructor & Destructor Documentation

proxygen::ZlibServerFilter::ZlibServerFilter	(	RequestHandler *	downstream,
		int32_t	compressionLevel,
		uint32_t	minimumCompressionSize,
		const std::shared_ptr< std::set< std::string >>	compressibleContentTypes
	)

inlineexplicit

Definition at line 27 of file ZlibServerFilter.h.

Referenced by proxygen::ZlibServerFilterFactory::onRequest().

       : Filter(downstream),
         compressionLevel_(compressionLevel),
         minimumCompressionSize_(minimumCompressionSize),
         compressibleContentTypes_(compressibleContentTypes) {}

Member Function Documentation

void proxygen::ZlibServerFilter::fail ( )

inlineprotected

Definition at line 147 of file ZlibServerFilter.h.

References proxygen::Filter::sendAbort().

Referenced by gtest_xml_test_utils.GTestXMLTestCase::_GetChildren(), fatal_test.FatalTests::is_debug_build(), sendBody(), sendEOM(), and sendHeaders().

               {
     Filter::sendAbort();
   }

bool proxygen::ZlibServerFilter::isCompressibleContentType ( const HTTPMessage & msg ) const

inlineprotectednoexcept

Definition at line 165 of file ZlibServerFilter.h.

References compressibleContentTypes_, proxygen::HTTP_HEADER_CONTENT_TYPE, and folly::toLowerAscii().

Referenced by sendHeaders().

                                                                         {
 
     auto responseContentType =
         msg.getHeaders().getSingleOrEmpty(HTTP_HEADER_CONTENT_TYPE);
     folly::toLowerAscii(responseContentType);
 
     // Handle  text/html; encoding=utf-8 case
     auto parameter_idx = responseContentType.find(';');
     if (parameter_idx != std::string::npos) {
      responseContentType = responseContentType.substr(0, parameter_idx);
     }
 
     auto idx = compressibleContentTypes_->find(responseContentType);
 
     if (idx != compressibleContentTypes_->end()) {
       return true;
     }
 
     return false;
   }

bool proxygen::ZlibServerFilter::isMinimumCompressibleSize ( const HTTPMessage & msg ) const

inlineprotectednoexcept

Definition at line 152 of file ZlibServerFilter.h.

References proxygen::HTTP_HEADER_CONTENT_LENGTH, minimumCompressionSize_, and uint32_t.

Referenced by sendHeaders().

                                                                         {
     auto contentLengthHeader =
         msg.getHeaders().getSingleOrEmpty(HTTP_HEADER_CONTENT_LENGTH);
 
     uint32_t contentLength = 0;
     if (!contentLengthHeader.empty()) {
       contentLength = folly::to<uint32_t>(contentLengthHeader);
     }
 
     return contentLength >= minimumCompressionSize_;
   }

void proxygen::ZlibServerFilter::sendBody ( std::unique_ptr< folly::IOBuf > body )

inlineoverridevirtualnoexcept

Implements proxygen::ResponseHandler.

Definition at line 86 of file ZlibServerFilter.h.

References chunked_, compress_, compressor_, fail(), header_, proxygen::HTTP_HEADER_CONTENT_LENGTH, folly::gen::move, responseMessage_, proxygen::Filter::sendBody(), proxygen::Filter::sendChunkHeader(), and proxygen::Filter::sendHeaders().

                                                                   {
     // If not compressing, pass the body through
     if (!compress_) {
       DCHECK(header_ == true);
       Filter::sendBody(std::move(body));
       return;
     }
 
     CHECK(compressor_ && !compressor_->hasError());
 
     // If it's chunked, never write the trailer, it will be written on EOM
     auto compressed = compressor_->compress(body.get(), !chunked_);
     if (compressor_->hasError()) {
       return fail();
     }
 
     auto compressedBodyLength = compressed->computeChainDataLength();
 
     if (chunked_) {
         // Send on the swallowed chunk header.
         Filter::sendChunkHeader(compressedBodyLength);
     } else {
       //Send the content length on compressed, non-chunked messages
       DCHECK(header_ == false);
       DCHECK(compress_ == true);
       auto& headers = responseMessage_->getHeaders();
       headers.set(HTTP_HEADER_CONTENT_LENGTH,
           folly::to<std::string>(compressedBodyLength));
 
       Filter::sendHeaders(*responseMessage_);
       header_  = true;
     }
 
     Filter::sendBody(std::move(compressed));
   }

void proxygen::ZlibServerFilter::sendChunkHeader ( size_t len )

inlineoverridevirtualnoexcept

Implements proxygen::ResponseHandler.

Definition at line 71 of file ZlibServerFilter.h.

References compress_, header_, and proxygen::Filter::sendChunkHeader().

                                                      {
     // The headers should have always been sent since the message is chunked
     DCHECK_EQ(header_, true) << "Headers should have already been sent.";
 
     // If not compressing, pass downstream, otherwise "swallow" it
     // to send after compressing the body.
     if (!compress_) {
       Filter::sendChunkHeader(len);
     }
 
     // Return without sending the chunk header.
     return;
   }

void proxygen::ZlibServerFilter::sendEOM ( )

inlineoverridevirtualnoexcept

Implements proxygen::ResponseHandler.

Definition at line 122 of file ZlibServerFilter.h.

References chunked_, compress_, compressor_, folly::IOBuf::copyBuffer(), fail(), folly::gen::move, proxygen::Filter::sendBody(), proxygen::Filter::sendChunkHeader(), proxygen::Filter::sendChunkTerminator(), and proxygen::Filter::sendEOM().

                                    {
 
     // Need to send the gzip trailer for compressed chunked messages
     if (compress_ && chunked_) {
 
       auto emptyBuffer = folly::IOBuf::copyBuffer("");
       CHECK(compressor_ && !compressor_->hasError());
       auto compressed = compressor_->compress(emptyBuffer.get(), true);
 
       if (compressor_->hasError()) {
         fail();
         return;
       }
 
       // "Inject" a chunk with the gzip trailer.
       Filter::sendChunkHeader(compressed->computeChainDataLength());
       Filter::sendBody(std::move(compressed));
       Filter::sendChunkTerminator();
     }
 
     Filter::sendEOM();
   }

void proxygen::ZlibServerFilter::sendHeaders ( HTTPMessage & msg )

inlineoverridevirtualnoexcept

NOTE: We take response message as non-const reference, to allow filters between your handler and client to be able to modify response if they want to.

eg. a compression filter might want to change the content-encoding

Implements proxygen::ResponseHandler.

Definition at line 37 of file ZlibServerFilter.h.

References chunked_, compress_, compressionLevel_, compressor_, fail(), proxygen::GZIP, header_, proxygen::HTTP_HEADER_CONTENT_ENCODING, isCompressibleContentType(), isMinimumCompressibleSize(), responseMessage_, and proxygen::Filter::sendHeaders().

                                                        {
     DCHECK(compressor_ == nullptr);
     DCHECK(header_ == false);
 
     chunked_ = msg.getIsChunked();
 
     // Make final determination of whether to compress
     compress_ = isCompressibleContentType(msg) &&
       (chunked_ || isMinimumCompressibleSize(msg));
 
     // Add the gzip header
     if (compress_) {
       auto& headers = msg.getHeaders();
       headers.set(HTTP_HEADER_CONTENT_ENCODING, "gzip");
     }
 
     // Initialize compressor
     compressor_ = std::make_unique<ZlibStreamCompressor>(
       proxygen::ZlibCompressionType::GZIP, compressionLevel_);
     if (!compressor_ || compressor_->hasError()) {
       fail();
       return;
     }
 
     // If it's chunked or not being compressed then the headers can be sent
     // if it's compressed and one body, then need to calculate content length.
     if (chunked_ || !compress_) {
       Filter::sendHeaders(msg);
       header_ = true;
     } else {
       responseMessage_ = std::make_unique<HTTPMessage>(msg);
     }
   }