proxygen::compress Namespace Reference

Classes
class	CompressionScheme
class	CompressionSimulator
struct	FrameFlags
struct	Header
class	HeaderPiece
class	HPACKScheme
class	QMINScheme
class	QPACKScheme
struct	SimParams
struct	SimStats
class	SimStreamingCallback

Typedefs
using	HeaderPieceList = std::deque< HeaderPiece >

Enumerations
enum	SchemeType { SchemeType::QPACK, SchemeType::QMIN, SchemeType::HPACK }

Functions
std::vector< compress::Header >	prepareMessageForCompression (const HTTPMessage &msg, std::vector< string > &cookies)
std::pair< vector< HPACKHeader >, uint32_t >	prepareHeaders (vector< Header > &headers)

Typedef Documentation

using proxygen::compress::HeaderPieceList = typedef std::deque<HeaderPiece>

Definition at line 59 of file HeaderPiece.h.

Enumeration Type Documentation

enum proxygen::compress::SchemeType

strong

Enumerator
QPACK
QMIN
HPACK

Definition at line 15 of file CompressionTypes.h.

{ QPACK, QMIN, HPACK };

Function Documentation

std::pair< std::vector< HPACKHeader >, uint32_t > proxygen::compress::prepareHeaders

(

vector< Header > &

headers

)

Definition at line 29 of file HPACKCodec.cpp.

References h, and uint32_t.

Referenced by proxygen::QPACKCodec::encode(), and proxygen::HPACKCodec::encode().

                               {
  // convert to HPACK API format
  std::pair<vector<HPACKHeader>, uint32_t> converted;
  converted.first.reserve(headers.size());
  for (const auto& h : headers) {
    // HPACKHeader automatically lowercases
    converted.first.emplace_back(*h.name, *h.value);
    auto& header = converted.first.back();
    converted.second += header.name.size() + header.value.size() + 2;
  }
  return converted;
}

std::vector< Header > proxygen::compress::prepareMessageForCompression	(	const HTTPMessage &	msg,
		std::vector< string > &	cookies
	)

Definition at line 83 of file CompressionUtils.cpp.

References proxygen::CONNECT, cookie, proxygen::HTTPHeaders::forEachWithCode(), proxygen::HTTPMessage::getHeaders(), proxygen::HTTPMessage::getMethod(), proxygen::HTTPMessage::getMethodString(), proxygen::HTTPHeaders::getSingleOrEmpty(), proxygen::HTTPMessage::getURL(), proxygen::HTTP_HEADER_COLON_AUTHORITY, proxygen::HTTP_HEADER_COLON_METHOD, proxygen::HTTP_HEADER_COLON_PATH, proxygen::HTTP_HEADER_COLON_SCHEME, proxygen::HTTP_HEADER_COOKIE, proxygen::HTTP_HEADER_HOST, proxygen::HTTPMessage::isSecure(), proxygen::headers::kAuthority, proxygen::headers::kHttp, proxygen::headers::kHttps, proxygen::headers::kMethod, proxygen::headers::kPath, proxygen::headers::kScheme, folly::ltrimWhitespace(), folly::split(), and value.

Referenced by proxygen::compress::CompressionSimulator::encode().

                                {
  std::vector<compress::Header> allHeaders;
  // The encode API is pretty bad.  We should just let HPACK directly encode
  // HTTP messages
  const HTTPHeaders& headers = msg.getHeaders();
  const string& host = headers.getSingleOrEmpty(HTTP_HEADER_HOST);
  bool isPublic = msg.getMethodString().empty();
  if (!isPublic) {
    allHeaders.emplace_back(HTTP_HEADER_COLON_METHOD, headers::kMethod,
                            msg.getMethodString());
    if (msg.getMethod() != HTTPMethod::CONNECT) {
      allHeaders.emplace_back(
          HTTP_HEADER_COLON_SCHEME, headers::kScheme,
          (msg.isSecure() ? headers::kHttps : headers::kHttp));
      allHeaders.emplace_back(HTTP_HEADER_COLON_PATH, headers::kPath,
                              msg.getURL());
    }

    if (!host.empty()) {
      allHeaders.emplace_back(
          HTTP_HEADER_COLON_AUTHORITY, headers::kAuthority, host);
    }
  }
  // Cookies are coalesced in the HAR file but need to be added as separate
  // headers to optimize compression ratio
  headers.forEachWithCode(
      [&](HTTPHeaderCode code, const string& name, const string& value) {
        if (code == HTTP_HEADER_COOKIE) {
          vector<folly::StringPiece> cookiePieces;
          folly::split(';', value, cookiePieces);
          cookies.reserve(cookies.size() + cookiePieces.size());
          for (auto cookie : cookiePieces) {
            cookies.push_back(ltrimWhitespace(cookie).str());
            allHeaders.emplace_back(code, name, cookies.back());
          }
        } else if (code != HTTP_HEADER_HOST && (isPublic || name[0] != ':')) {
          // HAR files contain actual serialized headers protocol headers like
          // :authority, which we are re-adding above.  Strip them so our
          // equality test works
          allHeaders.emplace_back(code, name, value);
        }
      });
  return allHeaders;
}