proxygen: CurlService::CurlClient Class Reference

#include <CurlClient.h>

Inheritance diagram for CurlService::CurlClient:

Public Member Functions
	CurlClient (folly::EventBase evb, proxygen::HTTPMethod httpMethod, const proxygen::URL &url, const proxygen::URL proxy, const proxygen::HTTPHeaders &headers, const std::string &inputFilename, bool h2c=false, unsigned short httpMajor=1, unsigned short httpMinor=1)

virtual	~CurlClient ()=default

void	initializeSsl (const std::string &caPath, const std::string &nextProtos, const std::string &certPath="", const std::string &keyPath="")

void	sslHandshakeFollowup (proxygen::HTTPUpstreamSession *session) noexcept

void	connectSuccess (proxygen::HTTPUpstreamSession *session) override

void	connectError (const folly::AsyncSocketException &ex) override

void	setTransaction (proxygen::HTTPTransaction *txn) noexceptoverride

void	detachTransaction () noexceptoverride

void	onHeadersComplete (std::unique_ptr< proxygen::HTTPMessage > msg) noexceptoverride

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

void	onTrailers (std::unique_ptr< proxygen::HTTPHeaders > trailers) noexceptoverride

void	onEOM () noexceptoverride

void	onUpgrade (proxygen::UpgradeProtocol protocol) noexceptoverride

void	onError (const proxygen::HTTPException &error) noexceptoverride

void	onEgressPaused () noexceptoverride

void	onEgressResumed () noexceptoverride

void	sendRequest (proxygen::HTTPTransaction *txn)

folly::SSLContextPtr	getSSLContext ()

const std::string &	getServerName () const

void	setFlowControlSettings (int32_t recvWindow)

const proxygen::HTTPMessage *	getResponse () const

void	setLogging (bool enabled)

Public Member Functions inherited from proxygen::HTTPConnector::Callback
virtual	~Callback ()

Public Member Functions inherited from proxygen::HTTPTransactionHandler
virtual void	onChunkHeader (size_t) noexcept

virtual void	onChunkComplete () noexcept

virtual void	onPushedTransaction (HTTPTransaction *) noexcept

virtual void	onExTransaction (HTTPTransaction *) noexcept

virtual void	onGoaway (ErrorCode) noexcept

virtual	~HTTPTransactionHandler ()

Static Public Member Functions
static proxygen::HTTPHeaders	parseHeaders (const std::string &headersString)

Protected Attributes
proxygen::HTTPTransaction *	txn_ {nullptr}

folly::EventBase *	evb_ {nullptr}

proxygen::HTTPMethod	httpMethod_

proxygen::URL	url_

std::unique_ptr< proxygen::URL >	proxy_

proxygen::HTTPMessage	request_

const std::string	inputFilename_

folly::SSLContextPtr	sslContext_

int32_t	recvWindow_ {0}

bool	loggingEnabled_ {true}

bool	h2c_ {false}

unsigned short	httpMajor_

unsigned short	httpMinor_

std::unique_ptr< proxygen::HTTPMessage >	response_

Detailed Description

Definition at line 20 of file CurlClient.h.

Constructor & Destructor Documentation

CurlService::CurlClient::CurlClient	(	folly::EventBase *	evb,
		proxygen::HTTPMethod	httpMethod,
		const proxygen::URL &	url,
		const proxygen::URL *	proxy,
		const proxygen::HTTPHeaders &	headers,
		const std::string &	inputFilename,
		bool	h2c = `false`,
		unsigned short	httpMajor = `1`,
		unsigned short	httpMinor = `1`
	)

Definition at line 23 of file CurlClient.cpp.

References proxygen::HTTPHeaders::add(), proxygen::HTTPHeaders::forEach(), proxygen::HTTPMessage::getHeaders(), proxygen::URL::getUrl(), proxy_, request_, and val.

     : evb_(evb),
       httpMethod_(httpMethod),
       url_(url),
       inputFilename_(inputFilename),
       h2c_(h2c),
       httpMajor_(httpMajor),
       httpMinor_(httpMinor) {
   if (proxy != nullptr) {
     proxy_ = std::make_unique<URL>(proxy->getUrl());
   }
 
   headers.forEach([this] (const string& header, const string& val) {
       request_.getHeaders().add(header, val);
     });
 }

virtual CurlService::CurlClient::~CurlClient ( )

virtualdefault

Member Function Documentation

void CurlService::CurlClient::connectError ( const folly::AsyncSocketException & ex )

overridevirtual

Implements proxygen::HTTPConnector::Callback.

Definition at line 178 of file CurlClient.cpp.

References proxygen::ERROR, proxygen::URL::getHostAndPort(), loggingEnabled_, and url_.

                                                                  {
   LOG_IF(ERROR, loggingEnabled_) << "Coudln't connect to "
                                  << url_.getHostAndPort() << ":" << ex.what();
 }

void CurlService::CurlClient::connectSuccess ( proxygen::HTTPUpstreamSession * session )

overridevirtual

Implements proxygen::HTTPConnector::Callback.

Definition at line 112 of file CurlClient.cpp.

References proxygen::HTTPSession::closeWhenIdle(), proxygen::URL::isSecure(), proxygen::HTTPUpstreamSession::newTransaction(), recvWindow_, sendRequest(), proxygen::HTTPSession::setFlowControl(), sslHandshakeFollowup(), and url_.

                                                             {
 
   if (url_.isSecure()) {
     sslHandshakeFollowup(session);
   }
 
   session->setFlowControl(recvWindow_, recvWindow_, recvWindow_);
   sendRequest(session->newTransaction(this));
   session->closeWhenIdle();
 }

void CurlService::CurlClient::detachTransaction ( )

overridevirtualnoexcept

Called once after a transaction successfully completes. It will be called even if a read or write error happened earlier. This is a terminal callback, which means that the HTTPTransaction object that gives this call will be invalid after this function completes.

Implements proxygen::HTTPTransactionHandler.

Definition at line 186 of file CurlClient.cpp.

186 {

187 }

const proxygen::HTTPMessage* CurlService::CurlClient::getResponse ( ) const

inline

Definition at line 72 of file CurlClient.h.

References response_.

Referenced by TEST().

                                                  {
     return response_.get();
   }

const string & CurlService::CurlClient::getServerName ( ) const

Definition at line 239 of file CurlClient.cpp.

References proxygen::HTTPMessage::getHeaders(), proxygen::URL::getHost(), proxygen::HTTPHeaders::getSingleOrEmpty(), proxygen::HTTP_HEADER_HOST, request_, and url_.

Referenced by getSSLContext().

                                               {
   const string& res = request_.getHeaders().getSingleOrEmpty(HTTP_HEADER_HOST);
   if (res.empty()) {
     return url_.getHost();
   }
   return res;
 }

folly::SSLContextPtr CurlService::CurlClient::getSSLContext ( )

inline

Definition at line 66 of file CurlClient.h.

References getServerName(), int32_t, setFlowControlSettings(), sslContext_, and string.

66 { return sslContext_; }

CurlService::CurlClient::sslContext_

folly::SSLContextPtr sslContext_

Definition: CurlClient.h:88

void CurlService::CurlClient::initializeSsl	(	const std::string &	caPath,
		const std::string &	nextProtos,
		const std::string &	certPath = `""`,
		const std::string &	keyPath = `""`
	)

Definition at line 69 of file CurlClient.cpp.

References h2c_, folly::ssl::SSLCommonOptions::kCipherList, and sslContext_.

                                                       {
   sslContext_ = std::make_shared<folly::SSLContext>();
   sslContext_->setOptions(SSL_OP_NO_COMPRESSION);
   sslContext_->setCipherList(folly::ssl::SSLCommonOptions::kCipherList);
   if (!caPath.empty()) {
     sslContext_->loadTrustedCertificates(caPath.c_str());
   }
   if (!certPath.empty() && !keyPath.empty()) {
     sslContext_->loadCertKeyPairFromFiles(certPath.c_str(), keyPath.c_str());
   }
   list<string> nextProtoList;
   folly::splitTo<string>(',', nextProtos, std::inserter(nextProtoList,
                                                         nextProtoList.begin()));
   sslContext_->setAdvertisedNextProtocols(nextProtoList);
   h2c_ = false;
 }

void CurlService::CurlClient::onBody ( std::unique_ptr< folly::IOBuf > chain )

overridevirtualnoexcept

Can be called multiple times per transaction. If you had previously called pauseIngress(), this callback will be delayed until you call resumeIngress().

Implements proxygen::HTTPTransactionHandler.

Definition at line 201 of file CurlClient.cpp.

References folly::IOBuf::data(), folly::IOBuf::length(), loggingEnabled_, and folly::IOBuf::next().

                                                                 {
   if (!loggingEnabled_) {
     return;
   }
   if (chain) {
     const IOBuf* p = chain.get();
     do {
       cout.write((const char*)p->data(), p->length());
       cout.flush();
       p = p->next();
     } while (p != chain.get());
   }
 }

void CurlService::CurlClient::onEgressPaused ( )

overridevirtualnoexcept

If the remote side's receive buffer fills up, this callback will be invoked so you can attempt to stop sending to the remote side.

Implements proxygen::HTTPTransactionHandler.

Definition at line 231 of file CurlClient.cpp.

References folly::INFO, and loggingEnabled_.

                                          {
   LOG_IF(INFO, loggingEnabled_) << "Egress paused";
 }

void CurlService::CurlClient::onEgressResumed ( )

overridevirtualnoexcept

This callback lets you know that the remote side has resumed reading and you can now continue to send data.

Implements proxygen::HTTPTransactionHandler.

Definition at line 235 of file CurlClient.cpp.

References folly::INFO, and loggingEnabled_.

                                           {
   LOG_IF(INFO, loggingEnabled_) << "Egress resumed";
 }

void CurlService::CurlClient::onEOM ( )

overridevirtualnoexcept

Can be called once per transaction. If you had previously called pauseIngress(), this callback will be delayed until you call resumeIngress(). After this callback is received, there will be no more normal ingress callbacks received (onEgress*() and onError() may still be invoked). The Handler should consider ingress complete after receiving this message. This Transaction is still valid, and work may still occur on it until detachTransaction is called.

Implements proxygen::HTTPTransactionHandler.

Definition at line 219 of file CurlClient.cpp.

References folly::INFO, and loggingEnabled_.

                                 {
   LOG_IF(INFO, loggingEnabled_) << "Got EOM";
 }

void CurlService::CurlClient::onError ( const proxygen::HTTPException & error )

overridevirtualnoexcept

Can be called at any time before detachTransaction(). This callback implies that an error has occurred. To determine if ingress or egress is affected, check the direciont on the HTTPException. If the direction is INGRESS, it MAY still be possible to send egress.

Implements proxygen::HTTPTransactionHandler.

Definition at line 227 of file CurlClient.cpp.

References proxygen::ERROR, folly::pushmi::operators::error(), and loggingEnabled_.

                                                             {
   LOG_IF(ERROR, loggingEnabled_) << "An error occurred: " << error.what();
 }

void CurlService::CurlClient::onHeadersComplete ( std::unique_ptr< proxygen::HTTPMessage > msg )

overridevirtualnoexcept

Called at most once per transaction. This is usually the first ingress callback. It is possible to get a read error before this however. If you had previously called pauseIngress(), this callback will be delayed until you call resumeIngress().

Implements proxygen::HTTPTransactionHandler.

Definition at line 189 of file CurlClient.cpp.

References loggingEnabled_, folly::gen::move, response_, and val.

                                                                        {
   response_ = std::move(msg);
   if (!loggingEnabled_) {
     return;
   }
   cout << response_->getStatusCode() << " "
        << response_->getStatusMessage() << endl;
   response_->getHeaders().forEach([&](const string& header, const string& val) {
     cout << header << ": " << val << endl;
   });
 }

void CurlService::CurlClient::onTrailers ( std::unique_ptr< proxygen::HTTPHeaders > trailers )

overridevirtualnoexcept

Can be called any number of times per transaction. If you had previously called pauseIngress(), this callback will be delayed until you call resumeIngress(). Trailers can be received once right before the EOM of a chunked HTTP/1.1 reponse or multiple times per transaction from SPDY and HTTP/2.0 HEADERS frames.

Implements proxygen::HTTPTransactionHandler.

Definition at line 215 of file CurlClient.cpp.

References folly::INFO, and loggingEnabled_.

                                                                {
   LOG_IF(INFO, loggingEnabled_) << "Discarding trailers";
 }

void CurlService::CurlClient::onUpgrade ( proxygen::UpgradeProtocol protocol )

overridevirtualnoexcept

Can be called once per transaction. If you had previously called pauseIngress(), this callback will be delayed until you call resumeIngress(). After this callback is invoked, further data will be forwarded using the onBody() callback. Once the data transfer is completed (EOF recevied in case of CONNECT), onEOM() callback will be invoked.

Implements proxygen::HTTPTransactionHandler.

Definition at line 223 of file CurlClient.cpp.

References folly::INFO, and loggingEnabled_.

                                                    {
   LOG_IF(INFO, loggingEnabled_) << "Discarding upgrade protocol";
 }

HTTPHeaders CurlService::CurlClient::parseHeaders ( const std::string & headersString )

static

Definition at line 48 of file CurlClient.cpp.

References proxygen::HTTPHeaders::add(), folly::empty(), folly::split(), and value.

Referenced by main().

                                                                    {
   vector<StringPiece> headersList;
   HTTPHeaders headers;
   folly::split(",", headersString, headersList);
   for (const auto& headerPair: headersList) {
     vector<StringPiece> nv;
     folly::split('=', headerPair, nv);
     if (nv.size() > 0) {
       if (nv[0].empty()) {
         continue;
       }
       StringPiece value("");
       if (nv.size() > 1) {
         value = nv[1];
       } // trim anything else
       headers.add(nv[0], value);
     }
   }
   return headers;
 }

void CurlService::CurlClient::sendRequest ( proxygen::HTTPTransaction * txn )

Definition at line 123 of file CurlClient.cpp.

References proxygen::HTTPHeaders::add(), folly::IOBuf::append(), proxygen::HTTPMessage::dumpMessage(), proxygen::HTTPMessage::getHeaders(), proxygen::URL::getHostAndPort(), proxygen::HTTPHeaders::getNumberOfValues(), proxygen::URL::getUrl(), h2c_, proxygen::HTTP_HEADER_ACCEPT, proxygen::HTTP_HEADER_HOST, proxygen::HTTP_HEADER_USER_AGENT, httpMajor_, httpMethod_, httpMinor_, inputFilename_, proxygen::URL::isSecure(), loggingEnabled_, proxygen::URL::makeRelativeURL(), folly::gen::move, proxy_, request_, proxygen::HTTPTransaction::sendBody(), proxygen::HTTPTransaction::sendEOM(), proxygen::HTTPTransaction::sendHeaders(), proxygen::HTTPMessage::setHTTPVersion(), proxygen::HTTPMessage::setMethod(), proxygen::HTTPMessage::setSecure(), proxygen::HTTPMessage::setURL(), txn_, uint16_t, url_, and folly::IOBuf::writableData().

Referenced by connectSuccess().

                                                  {
   txn_ = txn;
   request_.setMethod(httpMethod_);
   request_.setHTTPVersion(httpMajor_, httpMinor_);
   if (proxy_) {
     request_.setURL(url_.getUrl());
   } else {
     request_.setURL(url_.makeRelativeURL());
   }
   request_.setSecure(url_.isSecure());
   if (h2c_) {
     HTTP2Codec::requestUpgrade(request_);
   }
 
   if (!request_.getHeaders().getNumberOfValues(HTTP_HEADER_USER_AGENT)) {
     request_.getHeaders().add(HTTP_HEADER_USER_AGENT, "proxygen_curl");
   }
   if (!request_.getHeaders().getNumberOfValues(HTTP_HEADER_HOST)) {
     request_.getHeaders().add(HTTP_HEADER_HOST, url_.getHostAndPort());
   }
   if (!request_.getHeaders().getNumberOfValues(HTTP_HEADER_ACCEPT)) {
     request_.getHeaders().add("Accept", "*/*");
   }
   if (loggingEnabled_) {
     request_.dumpMessage(4);
   }
 
   txn_->sendHeaders(request_);
 
   unique_ptr<IOBuf> buf;
   if (httpMethod_ == HTTPMethod::POST) {
 
     const uint16_t kReadSize = 4096;
     ifstream inputFile(inputFilename_, ios::in | ios::binary);
 
     // Reading from the file by chunks
     // Important note: It's pretty bad to call a blocking i/o function like
     // ifstream::read() in an eventloop - but for the sake of this simple
     // example, we'll do it.
     // An alternative would be to put this into some folly::AsyncReader
     // object.
     while (inputFile.good()) {
       buf = IOBuf::createCombined(kReadSize);
       inputFile.read((char*)buf->writableData(), kReadSize);
       buf->append(inputFile.gcount());
       txn_->sendBody(move(buf));
     }
   }
 
   // note that sendBody() is called only for POST. It's fine not to call it
   // at all.
 
   txn_->sendEOM();
 }

void CurlService::CurlClient::setFlowControlSettings ( int32_t recvWindow )

Definition at line 108 of file CurlClient.cpp.

References recvWindow_.

Referenced by getSSLContext(), main(), and TEST().

                                                           {
   recvWindow_ = recvWindow;
 }

void CurlService::CurlClient::setLogging ( bool enabled )

inline

Definition at line 76 of file CurlClient.h.

References loggingEnabled_.

Referenced by TEST().

                                 {
     loggingEnabled_ = enabled;
   }

void CurlService::CurlClient::setTransaction ( proxygen::HTTPTransaction * txn )

overridevirtualnoexcept

Called once per transaction. This notifies the handler of which transaction it should talk to and will receive callbacks from.

Implements proxygen::HTTPTransactionHandler.

Definition at line 183 of file CurlClient.cpp.

183 {

184 }

void CurlService::CurlClient::sslHandshakeFollowup ( proxygen::HTTPUpstreamSession * session )

noexcept

Definition at line 89 of file CurlClient.cpp.

References folly::AsyncSSLSocket::getSelectedNextProtocol(), and string.

Referenced by connectSuccess().

                                                                            {
   AsyncSSLSocket* sslSocket = dynamic_cast<AsyncSSLSocket*>(
     session->getTransport());
 
   const unsigned char* nextProto = nullptr;
   unsigned nextProtoLength = 0;
   sslSocket->getSelectedNextProtocol(&nextProto, &nextProtoLength);
   if (nextProto) {
     VLOG(1) << "Client selected next protocol " <<
       string((const char*)nextProto, nextProtoLength);
   } else {
     VLOG(1) << "Client did not select a next protocol";
   }
 
   // Note: This ssl session can be used by defining a member and setting
   // something like sslSession_ = sslSocket->getSSLSession() and then
   // passing it to the connector::connectSSL() method
 }

Member Data Documentation

folly::EventBase* CurlService::CurlClient::evb_ {nullptr}

protected

Definition at line 82 of file CurlClient.h.

bool CurlService::CurlClient::h2c_ {false}

protected

Definition at line 91 of file CurlClient.h.

Referenced by initializeSsl(), and sendRequest().

unsigned short CurlService::CurlClient::httpMajor_

protected

Definition at line 92 of file CurlClient.h.

Referenced by sendRequest().

proxygen::HTTPMethod CurlService::CurlClient::httpMethod_

protected

Definition at line 83 of file CurlClient.h.

Referenced by sendRequest().

unsigned short CurlService::CurlClient::httpMinor_

protected

Definition at line 93 of file CurlClient.h.

Referenced by sendRequest().

const std::string CurlService::CurlClient::inputFilename_

protected

Definition at line 87 of file CurlClient.h.

Referenced by sendRequest().

bool CurlService::CurlClient::loggingEnabled_ {true}

protected

Definition at line 90 of file CurlClient.h.

Referenced by connectError(), onBody(), onEgressPaused(), onEgressResumed(), onEOM(), onError(), onHeadersComplete(), onTrailers(), onUpgrade(), sendRequest(), and setLogging().

std::unique_ptr<proxygen::URL> CurlService::CurlClient::proxy_

protected

Definition at line 85 of file CurlClient.h.

Referenced by CurlClient(), and sendRequest().

int32_t CurlService::CurlClient::recvWindow_ {0}

protected

Definition at line 89 of file CurlClient.h.

Referenced by connectSuccess(), and setFlowControlSettings().

proxygen::HTTPMessage CurlService::CurlClient::request_

protected

Definition at line 86 of file CurlClient.h.

Referenced by CurlClient(), getServerName(), and sendRequest().

std::unique_ptr<proxygen::HTTPMessage> CurlService::CurlClient::response_

protected

Definition at line 95 of file CurlClient.h.

Referenced by getResponse(), and onHeadersComplete().

folly::SSLContextPtr CurlService::CurlClient::sslContext_

protected

Definition at line 88 of file CurlClient.h.

Referenced by getSSLContext(), and initializeSsl().

proxygen::HTTPTransaction* CurlService::CurlClient::txn_ {nullptr}

protected

Definition at line 81 of file CurlClient.h.

Referenced by sendRequest().

proxygen::URL CurlService::CurlClient::url_

protected

Definition at line 84 of file CurlClient.h.

Referenced by connectError(), connectSuccess(), getServerName(), and sendRequest().

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

proxygen/httpclient/samples/curl/CurlClient.h
proxygen/httpclient/samples/curl/CurlClient.cpp

Public Member Functions

Static Public Member Functions

Protected Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation