proxygen: proxygen::HTTPConnector Class Reference

#include <HTTPConnector.h>

Inheritance diagram for proxygen::HTTPConnector:

Classes
class	Callback

Public Member Functions
	HTTPConnector (Callback callback, folly::HHWheelTimer timeoutSet)

	HTTPConnector (Callback *callback, const WheelTimerInstance &timeout)

	~HTTPConnector () override

void	reset ()

void	setPlaintextProtocol (const std::string &plaintextProto)

void	setHTTPVersionOverride (bool enabled)

void	connect (folly::EventBase *eventBase, const folly::SocketAddress &connectAddr, std::chrono::milliseconds timeoutMs=std::chrono::milliseconds(0), const folly::AsyncSocket::OptionMap &socketOptions=folly::AsyncSocket::emptyOptionMap, const folly::SocketAddress &bindAddr=folly::AsyncSocket::anyAddress())

void	connectSSL (folly::EventBase eventBase, const folly::SocketAddress &connectAddr, const std::shared_ptr< folly::SSLContext > &ctx, SSL_SESSION session=nullptr, std::chrono::milliseconds timeoutMs=std::chrono::milliseconds(0), const folly::AsyncSocket::OptionMap &socketOptions=folly::AsyncSocket::emptyOptionMap, const folly::SocketAddress &bindAddr=folly::AsyncSocket::anyAddress(), const std::string &serverName=empty_string)

std::chrono::milliseconds	timeElapsed ()

bool	isBusy () const

void	setHTTPCodecFactory (std::unique_ptr< DefaultHTTPCodecFactory > factory)

Protected Member Functions
void	connectSuccess () noexceptoverride

void	connectErr (const folly::AsyncSocketException &ex) noexceptoverride

Protected Member Functions inherited from folly::AsyncSocket::ConnectCallback
virtual	~ConnectCallback ()=default

Protected Attributes
Callback *	cb_

WheelTimerInstance	timeout_

folly::AsyncTransportWrapper::UniquePtr	socket_

wangle::TransportInfo	transportInfo_

std::string	plaintextProtocol_

TimePoint	connectStart_

std::unique_ptr< DefaultHTTPCodecFactory >	httpCodecFactory_

Detailed Description

This class establishes new connections to HTTP or HTTPS servers. It can be reused, even to connect to different addresses, but it can only service setting up one connection at a time.

Definition at line 31 of file HTTPConnector.h.

Constructor & Destructor Documentation

proxygen::HTTPConnector::HTTPConnector	(	Callback *	callback,
		folly::HHWheelTimer *	timeoutSet
	)

Construct a HTTPConnector. The constructor arguments are those parameters HTTPConnector needs to keep a copy of through the connection process.

Parameters

callback	The interface on which to receive the result. Whatever object is passed here MUST outlive this connector and MUST NOT be null.
timeoutSet	The timeout set to be used for the transactions that are opened on the session.

Definition at line 27 of file HTTPConnector.cpp.

Referenced by proxygen::HTTPConnector::Callback::~Callback().

29 : HTTPConnector(callback, WheelTimerInstance(timeoutSet)) {

30 }

proxygen::HTTPConnector::HTTPConnector

HTTPConnector(Callback *callback, folly::HHWheelTimer *timeoutSet)

Definition: HTTPConnector.cpp:27

proxygen::HTTPConnector::HTTPConnector	(	Callback *	callback,
		const WheelTimerInstance &	timeout
	)

Definition at line 32 of file HTTPConnector.cpp.

     : cb_(CHECK_NOTNULL(callback))
     , timeout_(timeout)
     , httpCodecFactory_(std::make_unique<DefaultHTTPCodecFactory>(false)) {}

proxygen::HTTPConnector::~HTTPConnector ( )

override

Clients may delete the connector at any time to cancel it. No callbacks will be received.

Definition at line 38 of file HTTPConnector.cpp.

References reset().

Referenced by proxygen::HTTPConnector::Callback::~Callback().

                               {
   reset();
 }

Member Function Documentation

void proxygen::HTTPConnector::connect	(	folly::EventBase *	eventBase,
		const folly::SocketAddress &	connectAddr,
		std::chrono::milliseconds	timeoutMs = `std::chrono::milliseconds(0)`,
		const folly::AsyncSocket::OptionMap &	socketOptions = `folly::AsyncSocket::emptyOptionMap`,
		const folly::SocketAddress &	bindAddr = `folly::AsyncSocket::anyAddress()`
	)

Begin the process of getting a plaintext connection to the server specified by 'connectAddr'. This function immediately starts async work and may invoke functions on Callback immediately.

Parameters

eventBase	The event base to put events on.
connectAddr	The address to connect to.
timeoutMs	Optional. If this value is greater than zero, then a connect error will be given if no connection is established within this amount of time.
socketOptions	Optional socket options to set on the connection.
bindAddr	Optional address to bind to locally.

Definition at line 59 of file HTTPConnector.cpp.

References connectStart_, proxygen::getCurrentTime(), isBusy(), wangle::TransportInfo::secure, socket_, and transportInfo_.

Referenced by ScopedServerTest::connectPlainText(), ProxyService::ProxyHandler::onRequest(), TEST(), and proxygen::HTTPConnector::Callback::~Callback().

                                       {
 
   DCHECK(!isBusy());
   transportInfo_ = wangle::TransportInfo();
   transportInfo_.secure = false;
   auto sock = new AsyncSocket(eventBase);
   socket_.reset(sock);
   connectStart_ = getCurrentTime();
   sock->connect(this, connectAddr, timeoutMs.count(),
                    socketOptions, bindAddr);
 }

void proxygen::HTTPConnector::connectErr ( const folly::AsyncSocketException & ex )

overrideprotectedvirtualnoexcept

connectErr() will be invoked if the connection attempt fails.

Parameters

ex	An exception describing the error that occurred.

Implements folly::AsyncSocket::ConnectCallback.

Definition at line 151 of file HTTPConnector.cpp.

References cb_, proxygen::HTTPConnector::Callback::connectError(), and socket_.

Referenced by setHTTPCodecFactory().

                                                                       {
   socket_.reset();
   if (cb_) {
     cb_->connectError(ex);
   }
 }

void proxygen::HTTPConnector::connectSSL	(	folly::EventBase *	eventBase,
		const folly::SocketAddress &	connectAddr,
		const std::shared_ptr< folly::SSLContext > &	ctx,
		SSL_SESSION *	session = `nullptr`,
		std::chrono::milliseconds	timeoutMs = `std::chrono::milliseconds(0)`,
		const folly::AsyncSocket::OptionMap &	socketOptions = `folly::AsyncSocket::emptyOptionMap`,
		const folly::SocketAddress &	bindAddr = `folly::AsyncSocket::anyAddress()`,
		const std::string &	serverName = `empty_string`
	)

Begin the process of getting a secure connection to the server specified by 'connectAddr'. This function immediately starts async work and may invoke functions on Callback immediately.

Parameters

eventBase	The event base to put events on.
connectAddr	The address to connect to.
ctx	SSL context to use. Must not be null.
session	Optional ssl session to use.
timeoutMs	Optional. If this value is greater than zero, then a connect error will be given if no connection is established within this amount of time.
socketOptions	Optional socket options to set on the connection.
bindAddr	Optional address to bind to locally.

Definition at line 76 of file HTTPConnector.cpp.

References connectStart_, proxygen::getCurrentTime(), isBusy(), wangle::TransportInfo::secure, socket_, and transportInfo_.

Referenced by ScopedServerTest::connectSSL(), and proxygen::HTTPConnector::Callback::~Callback().

                                {
 
   DCHECK(!isBusy());
   transportInfo_ = wangle::TransportInfo();
   transportInfo_.secure = true;
   auto sslSock = new AsyncSSLSocket(context, eventBase);
   if (session) {
     sslSock->setSSLSession(session, true /* take ownership */);
   }
   sslSock->setServerName(serverName);
   sslSock->forceCacheAddrOnFailure(true);
   socket_.reset(sslSock);
   connectStart_ = getCurrentTime();
   sslSock->connect(this, connectAddr, timeoutMs.count(),
                    socketOptions, bindAddr);
 }

void proxygen::HTTPConnector::connectSuccess ( )

overrideprotectedvirtualnoexcept

connectSuccess() will be invoked when the connection has been successfully established.

Implements folly::AsyncSocket::ConnectCallback.

Definition at line 110 of file HTTPConnector.cpp.

References wangle::TransportInfo::acceptTime, wangle::TransportInfo::appProtocol, cb_, codec, connectStart_, proxygen::HTTPConnector::Callback::connectSuccess(), proxygen::getCurrentTime(), folly::AsyncSSLSocket::getNegotiatedCipherName(), wangle::SSLUtil::getResumeState(), folly::AsyncSSLSocket::getSSLVersion(), httpCodecFactory_, proxygen::millisecondsSince(), folly::gen::move, plaintextProtocol_, wangle::TransportInfo::secure, socket_, wangle::TransportInfo::sslCipher, wangle::TransportInfo::sslResume, wangle::TransportInfo::sslSetupTime, wangle::TransportInfo::sslVersion, timeout_, transportInfo_, and proxygen::UPSTREAM.

                                             {
   if (!cb_) {
     return;
   }
 
   folly::SocketAddress localAddress;
   folly::SocketAddress peerAddress;
   socket_->getLocalAddress(&localAddress);
   socket_->getPeerAddress(&peerAddress);
 
   std::unique_ptr<HTTPCodec> codec;
 
   transportInfo_.acceptTime = getCurrentTime();
   if (transportInfo_.secure) {
     AsyncSSLSocket* sslSocket = socket_->getUnderlyingTransport<AsyncSSLSocket>();
 
     if (sslSocket) {
       transportInfo_.appProtocol =
           std::make_shared<std::string>(socket_->getApplicationProtocol());
       transportInfo_.sslSetupTime = millisecondsSince(connectStart_);
       transportInfo_.sslCipher = sslSocket->getNegotiatedCipherName() ?
         std::make_shared<std::string>(sslSocket->getNegotiatedCipherName()) :
         nullptr;
       transportInfo_.sslVersion = sslSocket->getSSLVersion();
       transportInfo_.sslResume = wangle::SSLUtil::getResumeState(sslSocket);
     }
     codec = httpCodecFactory_->getCodec(socket_->getApplicationProtocol(),
                                         TransportDirection::UPSTREAM, true);
   } else {
     codec = httpCodecFactory_->getCodec(plaintextProtocol_,
                                         TransportDirection::UPSTREAM, false);
   }
 
   HTTPUpstreamSession* session = new HTTPUpstreamSession(
     timeout_,
     std::move(socket_), localAddress, peerAddress,
     std::move(codec), transportInfo_, nullptr);
 
   cb_->connectSuccess(session);
 }

bool proxygen::HTTPConnector::isBusy ( ) const

inline

Returns: true iff this connector is busy setting up a connection. If this is false, it is safe to call connect() or connectSSL() on it again.

Definition at line 145 of file HTTPConnector.h.

References socket_.

Referenced by connect(), and connectSSL().

145 { return socket_.get(); }

proxygen::HTTPConnector::socket_

folly::AsyncTransportWrapper::UniquePtr socket_

Definition: HTTPConnector.h:159

void proxygen::HTTPConnector::reset ( )

Reset the object so that it can begin a new connection. No callbacks will be invoked as a result of executing this function. After this function returns, isBusy() will return false.

Definition at line 42 of file HTTPConnector.cpp.

References cb_, and socket_.

Referenced by proxygen::HTTPConnector::Callback::~Callback(), and ~HTTPConnector().

                           {
   if (socket_) {
     auto cb = cb_;
     cb_ = nullptr;
     socket_.reset(); // This invokes connectError() but will be ignored
     cb_ = cb;
   }
 }

void proxygen::HTTPConnector::setHTTPCodecFactory ( std::unique_ptr< DefaultHTTPCodecFactory > factory )

inline

Definition at line 147 of file HTTPConnector.h.

References connectErr(), proxygen::HTTPConnector::Callback::connectSuccess(), httpCodecFactory_, folly::gen::move, and folly::pushmi::__adl::noexcept().

                                                                            {
     httpCodecFactory_ = std::move(factory);
   }

void proxygen::HTTPConnector::setHTTPVersionOverride ( bool enabled )

Overrides the HTTP version to always use the latest and greatest version we support.

Definition at line 55 of file HTTPConnector.cpp.

References httpCodecFactory_.

Referenced by proxygen::HTTPConnector::Callback::~Callback().

                                                        {
   httpCodecFactory_->setForceHTTP1xCodecTo1_1(enabled);
 }

void proxygen::HTTPConnector::setPlaintextProtocol ( const std::string & plaintextProto )

Sets the plain text protocol to use after the connection is established.

Definition at line 51 of file HTTPConnector.cpp.

References plaintextProtocol_.

Referenced by main(), and proxygen::HTTPConnector::Callback::~Callback().

                                                                         {
   plaintextProtocol_ = plaintextProto;
 }

std::chrono::milliseconds proxygen::HTTPConnector::timeElapsed ( )

Returns: the number of milliseconds since connecting began, or zero if connecting hasn't started yet.

Definition at line 101 of file HTTPConnector.cpp.

References connectStart_, proxygen::millisecondsSince(), and proxygen::timePointInitialized().

Referenced by proxygen::HTTPConnector::Callback::~Callback().

                                                  {
   if (timePointInitialized(connectStart_)) {
     return millisecondsSince(connectStart_);
   }
   return std::chrono::milliseconds(0);
 }