proxygen::ResponseBuilder Class Reference

#include <ResponseBuilder.h>

Public Types
enum	UpgradeType { UpgradeType::CONNECT_REQUEST = 0, UpgradeType::HTTP_UPGRADE }

Public Member Functions
	ResponseBuilder (ResponseHandler *txn)
ResponseBuilder &	promise (const std::string &url, const std::string &host)
ResponseBuilder &	status (uint16_t code, const std::string &message)
template<typename T >
ResponseBuilder &	header (const std::string &headerIn, const T &value)
template<typename T >
ResponseBuilder &	header (HTTPHeaderCode code, const T &value)
ResponseBuilder &	body (std::unique_ptr< folly::IOBuf > bodyIn)
template<typename T >
ResponseBuilder &	body (T &&t)
ResponseBuilder &	closeConnection ()
ResponseBuilder &	trailers (const HTTPHeaders &trailers)
void	sendWithEOM ()
void	send ()
void	acceptUpgradeRequest (UpgradeType upgradeType, const std::string upgradeProtocol="")
void	rejectUpgradeRequest ()
ResponseBuilder &	setEgressWebsocketHeaders ()

Private Attributes
ResponseHandler *const	txn_ {nullptr}
std::unique_ptr< HTTPMessage >	headers_
std::unique_ptr< folly::IOBuf >	body_
std::unique_ptr< HTTPHeaders >	trailers_
bool	sendEOM_ {false}

Detailed Description

Helps you make responses and send them on demand.

NOTE: We don't do any correctness checks here, we depend on state machine in HTTPTransaction to tell us when an error occurs

Three expected use cases are

1. Send all response at once. If this is an error response, most probably you also want 'closeConnection'.

ResponseBuilder(handler) .status(200, "OK") .body(...) .sendWithEOM();

1. Sending back response in chunks.

ResponseBuilder(handler) .status(200, "OK") .body(...) .send(); // Without WithEOM we make it chunked

1 or more time

ResponseBuilder(handler) .body(...) .send();

At last

ResponseBuilder(handler) .body(...) .sendWithEOM();

1. Accept or reject Upgrade Requests

ResponseBuilder(handler) .acceptUpgradeRequest() // send '200 OK' without EOM

or

ResponseBuilder(handler) .rejectUpgradeRequest() // send '400 Bad Request'

Definition at line 64 of file ResponseBuilder.h.

Member Enumeration Documentation

enum proxygen::ResponseBuilder::UpgradeType

strong

Enumerator
CONNECT_REQUEST
HTTP_UPGRADE

Definition at line 181 of file ResponseBuilder.h.

                         {
    CONNECT_REQUEST = 0,
    HTTP_UPGRADE,
  };

Constructor & Destructor Documentation

proxygen::ResponseBuilder::ResponseBuilder ( ResponseHandler *  txn )

inlineexplicit

Definition at line 66 of file ResponseBuilder.h.

                                                : txn_(txn) {
  }

Member Function Documentation

void proxygen::ResponseBuilder::acceptUpgradeRequest ( UpgradeType  upgradeType, const std::string  upgradeProtocol = ""  )

inline

Definition at line 186 of file ResponseBuilder.h.

References CONNECT_REQUEST, headers_, proxygen::HTTP_HEADER_CONNECTION, proxygen::HTTP_HEADER_UPGRADE, proxygen::ResponseHandler::sendHeaders(), and txn_.

                                                                  {
    headers_ = std::make_unique<HTTPMessage>();
    if (upgradeType == UpgradeType::CONNECT_REQUEST) {
      headers_->constructDirectResponse({1, 1}, 200, "OK");
    } else {
      CHECK(!upgradeProtocol.empty());
      headers_->constructDirectResponse({1, 1}, 101, "Switching Protocols");
      headers_->getHeaders().add(HTTP_HEADER_UPGRADE, upgradeProtocol);
      headers_->getHeaders().add(HTTP_HEADER_CONNECTION, "Upgrade");
    }
    txn_->sendHeaders(*headers_);
  }

ResponseBuilder& proxygen::ResponseBuilder::body ( std::unique_ptr< folly::IOBuf >  bodyIn )

inline

Definition at line 99 of file ResponseBuilder.h.

References body_, and folly::gen::move.

Referenced by body(), ZlibServerFilterTest::exercise_compression(), EchoService::EchoHandler::onEOM(), PushService::PushRequestHandler::onEOM(), proxygen::DirectResponseHandler::onEOM(), proxygen::ScopedHandler< HandlerType >::onEOM(), TestHandlerFactory::TestHandler::onEOM(), StaticService::StaticHandler::onRequest(), PushService::PushRequestHandler::onRequest(), ProxyService::ProxyHandler::onRequest(), and StaticService::StaticHandler::readFile().

                                                          {
    if (bodyIn) {
      if (body_) {
        body_->prependChain(std::move(bodyIn));
      } else {
        body_ = std::move(bodyIn);
      }
    }

    return *this;
  }

template<typename T >

ResponseBuilder& proxygen::ResponseBuilder::body ( T &&  t )

inline

Definition at line 112 of file ResponseBuilder.h.

References body(), folly::IOBuf::maybeCopyBuffer(), and folly::pushmi::detail::t.

                               {
    return body(folly::IOBuf::maybeCopyBuffer(
        folly::to<std::string>(std::forward<T>(t))));
  }

ResponseBuilder& proxygen::ResponseBuilder::closeConnection ( )

inline

Definition at line 117 of file ResponseBuilder.h.

References header(), and proxygen::HTTP_HEADER_CONNECTION.

Referenced by proxygen::RequestHandlerAdaptor::onError(), and proxygen::RequestHandlerAdaptor::onHeadersComplete().

                                     {
    return header(HTTP_HEADER_CONNECTION, "close");
  }

template<typename T >

ResponseBuilder& proxygen::ResponseBuilder::header ( const std::string &  headerIn, const T &  value  )

inline

Definition at line 86 of file ResponseBuilder.h.

References headers_.

Referenced by closeConnection(), ZlibServerFilterTest::exercise_compression(), PushService::PushRequestHandler::onEOM(), EchoService::EchoHandler::onEOM(), TestHandlerFactory::TestHandler::onEOM(), and TEST_F().

                                                                     {
    CHECK(headers_) << "You need to call `status` before adding headers";
    headers_->getHeaders().add(headerIn, value);
    return *this;
  }

template<typename T >

ResponseBuilder& proxygen::ResponseBuilder::header ( HTTPHeaderCode  code, const T &  value  )

inline

Definition at line 93 of file ResponseBuilder.h.

References headers_.

                                                               {
    CHECK(headers_) << "You need to call `status` before adding headers";
    headers_->getHeaders().add(code, value);
    return *this;
  }

ResponseBuilder& proxygen::ResponseBuilder::promise ( const std::string &  url, const std::string &  host  )

inline

Definition at line 69 of file ResponseBuilder.h.

References headers_, and proxygen::HTTP_HEADER_HOST.

Referenced by PushService::PushRequestHandler::onRequest().

                                                                        {
    headers_ = std::make_unique<HTTPMessage>();
    headers_->setHTTPVersion(1, 1);
    headers_->setURL(url);
    headers_->getHeaders().set(HTTP_HEADER_HOST, host);
    return *this;
  }

void proxygen::ResponseBuilder::rejectUpgradeRequest ( )

inline

Definition at line 200 of file ResponseBuilder.h.

References headers_, proxygen::ResponseHandler::sendEOM(), proxygen::ResponseHandler::sendHeaders(), and txn_.

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

                              {
    headers_ = std::make_unique<HTTPMessage>();
    headers_->constructDirectResponse({1, 1}, 400, "Bad Request");
    txn_->sendHeaders(*headers_);
    txn_->sendEOM();
  }

void proxygen::ResponseBuilder::send ( )

inline

Definition at line 131 of file ResponseBuilder.h.

References body_, folly::gen::chunked(), proxygen::ResponseHandler::getTransaction(), headers_, proxygen::HTTP_HEADER_CONTENT_LENGTH, folly::gen::move, SCOPE_EXIT, proxygen::ResponseHandler::sendBody(), proxygen::ResponseHandler::sendChunkHeader(), proxygen::ResponseHandler::sendChunkTerminator(), proxygen::ResponseHandler::sendEOM(), sendEOM_, proxygen::ResponseHandler::sendHeaders(), proxygen::HTTPTransaction::sendTrailers(), trailers_, and txn_.

Referenced by ProxyService::ProxyHandler::connectSuccess(), ZlibServerFilterTest::exercise_compression(), proxygen::RequestHandlerAdaptor::onHeadersComplete(), StaticService::StaticHandler::onRequest(), StaticService::StaticHandler::readFile(), sendWithEOM(), and TEST_F().

              {
    // Once we send them, we don't want to send them again
    SCOPE_EXIT { headers_.reset(); };

    // By default, chunked
    bool chunked = true;

    // If we have complete response, we can use Content-Length and get done
    if (headers_ && sendEOM_) {
      chunked = false;
    }

    if (headers_) {
      // We don't need to add Content-Length or Encoding for 1xx responses
      if (headers_->isResponse() && headers_->getStatusCode() >= 200) {
        if (chunked) {
          headers_->setIsChunked(true);
        } else {
          const auto len = body_ ? body_->computeChainDataLength() : 0;
          headers_->getHeaders().add(
              HTTP_HEADER_CONTENT_LENGTH,
              folly::to<std::string>(len));
        }
      }

      txn_->sendHeaders(*headers_);
    }

    if (body_) {
      if (chunked) {
        txn_->sendChunkHeader(body_->computeChainDataLength());
        txn_->sendBody(std::move(body_));
        txn_->sendChunkTerminator();
      } else {
        txn_->sendBody(std::move(body_));
      }
    }

    if (sendEOM_) {
      if (trailers_) {
        auto txn = txn_->getTransaction();
        if (txn) {
          txn->sendTrailers(*trailers_);
        }
        trailers_.reset();
      }
      txn_->sendEOM();
    }
  }

void proxygen::ResponseBuilder::sendWithEOM ( )

inline

Definition at line 126 of file ResponseBuilder.h.

References send(), and sendEOM_.

Referenced by ProxyService::ProxyHandler::connectError(), ZlibServerFilterTest::exercise_compression(), PushService::PushRequestHandler::onEOM(), EchoService::EchoHandler::onEOM(), proxygen::DirectResponseHandler::onEOM(), proxygen::ScopedHandler< HandlerType >::onEOM(), TestHandlerFactory::TestHandler::onEOM(), proxygen::RequestHandlerAdaptor::onError(), proxygen::RequestHandlerAdaptor::onHeadersComplete(), StaticService::StaticHandler::onRequest(), PushService::PushRequestHandler::onRequest(), ProxyService::ProxyHandler::onRequest(), StaticService::StaticHandler::readFile(), and TEST_F().

                     {
    sendEOM_ = true;
    send();
  }

ResponseBuilder& proxygen::ResponseBuilder::setEgressWebsocketHeaders ( )

inline

Definition at line 207 of file ResponseBuilder.h.

References headers_.

                                               {
    headers_->setEgressWebsocketUpgrade();
    return *this;
  }

ResponseBuilder& proxygen::ResponseBuilder::status ( uint16_t  code, const std::string &  message  )

inline

Definition at line 77 of file ResponseBuilder.h.

References headers_.

Referenced by ProxyService::ProxyHandler::connectError(), ProxyService::ProxyHandler::connectSuccess(), ZlibServerFilterTest::exercise_compression(), PushService::PushRequestHandler::onEOM(), EchoService::EchoHandler::onEOM(), proxygen::DirectResponseHandler::onEOM(), proxygen::ScopedHandler< HandlerType >::onEOM(), TestHandlerFactory::TestHandler::onEOM(), proxygen::RequestHandlerAdaptor::onError(), proxygen::RequestHandlerAdaptor::onHeadersComplete(), StaticService::StaticHandler::onRequest(), PushService::PushRequestHandler::onRequest(), ProxyService::ProxyHandler::onRequest(), and TEST_F().

                                                                   {
    headers_ = std::make_unique<HTTPMessage>();
    headers_->setHTTPVersion(1, 1);
    headers_->setStatusCode(code);
    headers_->setStatusMessage(message);
    return *this;
  }

ResponseBuilder& proxygen::ResponseBuilder::trailers ( const HTTPHeaders &  trailers )

inline

Definition at line 121 of file ResponseBuilder.h.

References trailers_.

                                                         {
    trailers_.reset(new HTTPHeaders(trailers));
    return *this;
  }

Member Data Documentation

std::unique_ptr<folly::IOBuf> proxygen::ResponseBuilder::body_

private

Definition at line 216 of file ResponseBuilder.h.

Referenced by body(), and send().

std::unique_ptr<HTTPMessage> proxygen::ResponseBuilder::headers_

private

Definition at line 215 of file ResponseBuilder.h.

Referenced by acceptUpgradeRequest(), header(), promise(), rejectUpgradeRequest(), send(), setEgressWebsocketHeaders(), and status().

bool proxygen::ResponseBuilder::sendEOM_ {false}

private

Definition at line 220 of file ResponseBuilder.h.

Referenced by send(), and sendWithEOM().

std::unique_ptr<HTTPHeaders> proxygen::ResponseBuilder::trailers_

private

Definition at line 217 of file ResponseBuilder.h.

Referenced by send(), and trailers().

ResponseHandler* const proxygen::ResponseBuilder::txn_ {nullptr}

private

Definition at line 213 of file ResponseBuilder.h.

Referenced by acceptUpgradeRequest(), rejectUpgradeRequest(), and send().

---

The documentation for this class was generated from the following file:

• proxygen/httpserver/ResponseBuilder.h