proxygen: proxygen::HTTPSessionAcceptor Class Reference

#include <HTTPSessionAcceptor.h>

Inheritance diagram for proxygen::HTTPSessionAcceptor:

Public Member Functions
	HTTPSessionAcceptor (const AcceptorConfiguration &accConfig)

	HTTPSessionAcceptor (const AcceptorConfiguration &accConfig, std::shared_ptr< HTTPCodecFactory > codecFactory)

	~HTTPSessionAcceptor () override

void	setDefaultErrorPage (std::unique_ptr< HTTPErrorPage > generator)

const HTTPErrorPage *	getDefaultErrorPage () const

void	setDiagnosticErrorPage (std::unique_ptr< HTTPErrorPage > generator)

const HTTPErrorPage *	getDiagnosticErrorPage () const

virtual const HTTPErrorPage *	getErrorPage (const folly::SocketAddress &addr) const

void	setCodecFactory (std::shared_ptr< HTTPCodecFactory > codecFactory)

std::shared_ptr< HTTPCodecFactory >	getCodecFactory ()

virtual HTTPTransaction::Handler *	newHandler (HTTPTransaction &txn, HTTPMessage *msg) noexcept=0

void	setSessionInfoCallback (HTTPSession::InfoCallback *cb)

virtual bool	getHttp2PrioritiesEnabled ()

Public Member Functions inherited from proxygen::HTTPAcceptor
	HTTPAcceptor (const AcceptorConfiguration &accConfig)

bool	isInternal () const

virtual const WheelTimerInstance &	getTransactionTimeoutSet ()

void	init (folly::AsyncServerSocket serverSocket, folly::EventBase eventBase, wangle::SSLStats *=nullptr) override

const AcceptorConfiguration &	getConfig () const

Public Member Functions inherited from wangle::Acceptor
	Acceptor (const ServerSocketConfig &accConfig)

	~Acceptor () override

virtual void	setSSLCacheProvider (const std::shared_ptr< SSLCacheProvider > &cacheProvider)

virtual void	resetSSLContextConfigs ()

void	addSSLContextConfig (const SSLContextConfig &sslCtxConfig)

SSLContextManager *	getSSLContextManager () const

virtual void	setTLSTicketSecrets (const std::vector< std::string > &oldSecrets, const std::vector< std::string > &currentSecrets, const std::vector< std::string > &newSecrets)

uint32_t	getNumConnections () const

virtual folly::EventBase *	getEventBase () const

virtual wangle::ConnectionManager *	getConnectionManager ()

void	addConnection (wangle::ManagedConnection *connection)

State	getState () const

std::chrono::milliseconds	getConnTimeout () const

const std::string &	getName () const

std::chrono::milliseconds	getSSLHandshakeTimeout () const

void	setGracefulShutdownTimeout (std::chrono::milliseconds gracefulShutdown)

std::chrono::milliseconds	getGracefulShutdownTimeout () const

virtual void	forceStop ()

bool	isSSL () const

const ServerSocketConfig &	getConfig () const

virtual void	onDoneAcceptingConnection (int fd, const folly::SocketAddress &clientAddr, std::chrono::steady_clock::time_point acceptTime) noexcept

void	processEstablishedConnection (int fd, const folly::SocketAddress &clientAddr, std::chrono::steady_clock::time_point acceptTime, TransportInfo &tinfo) noexcept

virtual void	startHandshakeManager (folly::AsyncSSLSocket::UniquePtr sslSock, Acceptor *acceptor, const folly::SocketAddress &clientAddr, std::chrono::steady_clock::time_point acceptTime, TransportInfo &tinfo) noexcept

void	drainAllConnections ()

virtual void	drainConnections (double pctToDrain)

void	dropAllConnections ()

virtual void	dropConnections (double pctToDrop)

virtual void	plaintextConnectionReady (folly::AsyncTransportWrapper::UniquePtr sock, const folly::SocketAddress &clientAddr, const std::string &nextProtocolName, SecureTransportType secureTransportType, TransportInfo &tinfo)

void	connectionReady (folly::AsyncTransportWrapper::UniquePtr sock, const folly::SocketAddress &clientAddr, const std::string &nextProtocolName, SecureTransportType secureTransportType, TransportInfo &tinfo)

virtual void	sslConnectionReady (folly::AsyncTransportWrapper::UniquePtr sock, const folly::SocketAddress &clientAddr, const std::string &nextProtocol, SecureTransportType secureTransportType, TransportInfo &tinfo)

virtual void	sslConnectionError (const folly::exception_wrapper &ex)

virtual void	updateSSLStats (const folly::AsyncTransportWrapper *, std::chrono::milliseconds, SSLErrorEnum) noexcept

Public Member Functions inherited from folly::AsyncServerSocket::AcceptCallback
virtual	~AcceptCallback ()=default

virtual void	acceptStarted () noexcept

Public Member Functions inherited from wangle::ConnectionManager::Callback
virtual	~Callback ()=default

Public Member Functions inherited from folly::AsyncUDPServerSocket::Callback
virtual void	onListenPaused () noexcept

virtual void	onListenResumed () noexcept

virtual	~Callback ()=default

Protected Member Functions
virtual HTTPSessionController *	getController ()

HTTPSession::InfoCallback *	getSessionInfoCallback ()

void	onNewConnection (folly::AsyncTransportWrapper::UniquePtr sock, const folly::SocketAddress *address, const std::string &nextProtocol, wangle::SecureTransportType secureTransportType, const wangle::TransportInfo &tinfo) override

folly::AsyncSocket::UniquePtr	makeNewAsyncSocket (folly::EventBase *base, int fd) override

virtual size_t	dropIdleConnections (size_t num)

virtual void	onSessionCreationError (ProxygenError)

Protected Member Functions inherited from wangle::Acceptor
virtual uint64_t	getConnectionCountForLoadShedding (void) const

virtual uint64_t	getActiveConnectionCountForLoadShedding () const

virtual uint64_t	getWorkerMaxConnections () const

virtual bool	canAccept (const folly::SocketAddress &)

void	onListenStarted () noexceptoverride

void	onListenStopped () noexceptoverride

void	onDataAvailable (std::shared_ptr< folly::AsyncUDPSocket >, const folly::SocketAddress &, std::unique_ptr< folly::IOBuf >, bool) noexceptoverride

virtual folly::AsyncSSLSocket::UniquePtr	makeNewAsyncSSLSocket (const std::shared_ptr< folly::SSLContext > &ctx, folly::EventBase *base, int fd)

virtual void	onConnectionsDrained ()

void	connectionAccepted (int fd, const folly::SocketAddress &clientAddr) noexceptoverride

void	acceptError (const std::exception &ex) noexceptoverride

void	acceptStopped () noexceptoverride

void	onEmpty (const wangle::ConnectionManager &cm) override

void	onConnectionAdded (const ManagedConnection *) override

void	onConnectionRemoved (const ManagedConnection *) override

void	setLoadShedConfig (std::shared_ptr< const LoadShedConfiguration > loadShedConfig, const IConnectionCounter *counter)

virtual void	initDownstreamConnectionManager (folly::EventBase *eventBase)

virtual DefaultToFizzPeekingCallback *	getFizzPeeker ()

virtual std::shared_ptr< fizz::server::FizzServerContext >	createFizzContext ()

virtual std::shared_ptr< fizz::server::TicketCipher >	createFizzTicketCipher (folly::Optional< std::string >=folly::none)

void	updateFizzContext (fizz::server::FizzServerContext *)

Protected Attributes
HTTPSessionStats *	downstreamSessionStats_ {nullptr}

Protected Attributes inherited from proxygen::HTTPAcceptor
AcceptorConfiguration	accConfig_

Protected Attributes inherited from wangle::Acceptor
folly::EventBase *	base_ {nullptr}

const ServerSocketConfig	accConfig_

folly::AsyncSocket::OptionMap	socketOptions_

std::unique_ptr< SSLContextManager >	sslCtxManager_

SecurityProtocolContextManager	securityProtocolCtxManager_

TLSPlaintextPeekingCallback	tlsPlaintextPeekingCallback_

DefaultToSSLPeekingCallback	defaultPeekingCallback_

DefaultToFizzPeekingCallback	defaultFizzPeeker_

wangle::ConnectionManager::UniquePtr	downstreamConnectionManager_

std::shared_ptr< SSLCacheProvider >	cacheProvider_

wangle::TLSTicketKeySeeds	currentSecrets_

Private Member Functions
	HTTPSessionAcceptor (const HTTPSessionAcceptor &)=delete

HTTPSessionAcceptor &	operator= (const HTTPSessionAcceptor &)=delete

Private Member Functions inherited from proxygen::HTTPSessionBase::InfoCallback
virtual	~InfoCallback ()

virtual void	onCreate (const HTTPSessionBase &)

virtual void	onFullHandshakeCompletion (const HTTPSessionBase &)

virtual void	onIngressError (const HTTPSessionBase &, ProxygenError)

virtual void	onIngressEOF ()

virtual void	onRead (const HTTPSessionBase &, size_t)

virtual void	onWrite (const HTTPSessionBase &, size_t)

virtual void	onRequestBegin (const HTTPSessionBase &)

virtual void	onRequestEnd (const HTTPSessionBase &, uint32_t)

virtual void	onActivateConnection (const HTTPSessionBase &)

virtual void	onDeactivateConnection (const HTTPSessionBase &)

virtual void	onDestroy (const HTTPSessionBase &)

virtual void	onIngressMessage (const HTTPSessionBase &, const HTTPMessage &)

virtual void	onIngressLimitExceeded (const HTTPSessionBase &)

virtual void	onIngressPaused (const HTTPSessionBase &)

virtual void	onTransactionDetached (const HTTPSessionBase &)

virtual void	onPingReplySent (int64_t)

virtual void	onPingReplyReceived ()

virtual void	onSettingsOutgoingStreamsFull (const HTTPSessionBase &)

virtual void	onSettingsOutgoingStreamsNotFull (const HTTPSessionBase &)

virtual void	onFlowControlWindowClosed (const HTTPSessionBase &)

virtual void	onEgressBuffered (const HTTPSessionBase &)

virtual void	onEgressBufferCleared (const HTTPSessionBase &)

virtual void	onSettings (const HTTPSessionBase &, const SettingsList &)

virtual void	onSettingsAck (const HTTPSessionBase &)

Private Attributes
std::unique_ptr< HTTPErrorPage >	defaultErrorPage_

std::unique_ptr< HTTPErrorPage >	diagnosticErrorPage_

std::shared_ptr< HTTPCodecFactory >	codecFactory_ {}

SimpleController	simpleController_

HTTPSession::InfoCallback *	sessionInfoCb_ {nullptr}

Static Private Attributes
static const folly::SocketAddress	unknownSocketAddress_

Additional Inherited Members
Public Types inherited from wangle::Acceptor
enum	State : uint32_t { State::kInit, State::kRunning, State::kDraining, State::kDone }

Static Public Member Functions inherited from wangle::Acceptor
static uint64_t	getTotalNumPendingSSLConns ()

Detailed Description

Specialization of Acceptor that serves as an abstract base for acceptors that support HTTP and related protocols.

Definition at line 28 of file HTTPSessionAcceptor.h.

Constructor & Destructor Documentation

proxygen::HTTPSessionAcceptor::HTTPSessionAcceptor ( const AcceptorConfiguration & accConfig )

explicit

Definition at line 26 of file HTTPSessionAcceptor.cpp.

Referenced by onSessionCreationError().

27 : HTTPSessionAcceptor(accConfig, nullptr) {}

proxygen::HTTPSessionAcceptor::HTTPSessionAcceptor

HTTPSessionAcceptor(const AcceptorConfiguration &accConfig)

Definition: HTTPSessionAcceptor.cpp:26

proxygen::HTTPSessionAcceptor::HTTPSessionAcceptor	(	const AcceptorConfiguration &	accConfig,
		std::shared_ptr< HTTPCodecFactory >	codecFactory
	)

explicit

Definition at line 29 of file HTTPSessionAcceptor.cpp.

References proxygen::HTTPAcceptor::accConfig_, and codecFactory_.

                                                :
     HTTPAcceptor(accConfig),
     codecFactory_(codecFactory),
     simpleController_(this) {
   if (!codecFactory_) {
     codecFactory_ =
         std::make_shared<HTTPDefaultSessionCodecFactory>(accConfig_);
   }
 }

proxygen::HTTPSessionAcceptor::~HTTPSessionAcceptor ( )

override

Definition at line 41 of file HTTPSessionAcceptor.cpp.

41 {

42 }

proxygen::HTTPSessionAcceptor::HTTPSessionAcceptor ( const HTTPSessionAcceptor & )

privatedelete

Member Function Documentation

size_t proxygen::HTTPSessionAcceptor::dropIdleConnections ( size_t num )

protectedvirtual

Definition at line 127 of file HTTPSessionAcceptor.cpp.

References wangle::Acceptor::downstreamConnectionManager_.

Referenced by makeNewAsyncSocket().

                                                           {
   // release in batch for more efficiency
   VLOG(6) << "attempt to release resource";
   return downstreamConnectionManager_->dropIdleConnections(num);
 }

std::shared_ptr<HTTPCodecFactory> proxygen::HTTPSessionAcceptor::getCodecFactory ( )

inline

return the codec factory for this session

Definition at line 86 of file HTTPSessionAcceptor.h.

References codecFactory_, newHandler(), and folly::pushmi::__adl::noexcept().

                                                     {
     return codecFactory_;
   }

virtual HTTPSessionController* proxygen::HTTPSessionAcceptor::getController ( )

inlineprotectedvirtual

This function is invoked when a new session is created to get the controller to associate with the new session. Child classes may override this function to provide their own more sophisticated controller here.

Definition at line 119 of file HTTPSessionAcceptor.h.

References simpleController_.

Referenced by onNewConnection().

                                                  {
     return &simpleController_;
   }

const HTTPErrorPage* proxygen::HTTPSessionAcceptor::getDefaultErrorPage ( ) const

inline

Access the default error page generator.

Definition at line 47 of file HTTPSessionAcceptor.h.

References defaultErrorPage_.

                                                    {
     return defaultErrorPage_.get();
   }

const HTTPErrorPage* proxygen::HTTPSessionAcceptor::getDiagnosticErrorPage ( ) const

inline

Access the diagnostic error page generator.

Definition at line 61 of file HTTPSessionAcceptor.h.

References addr, diagnosticErrorPage_, and getErrorPage().

                                                       {
     return diagnosticErrorPage_.get();
   }

const HTTPErrorPage * proxygen::HTTPSessionAcceptor::getErrorPage ( const folly::SocketAddress & addr ) const

virtual

Access the right error page generator for a connection.

Parameters

localAddr Address of the local end of the connection.

Returns: The diagnostic error page generator if one has been set AND the connection is to an internal VIP, or else the default error page generator if one has been set, or else nullptr.

Definition at line 44 of file HTTPSessionAcceptor.cpp.

References defaultErrorPage_, diagnosticErrorPage_, proxygen::HTTPAcceptor::isInternal(), and folly::SocketAddress::isPrivateAddress().

Referenced by getDiagnosticErrorPage(), proxygen::SimpleController::getParseErrorHandler(), and proxygen::SimpleController::getTransactionTimeoutHandler().

                                      {
   const HTTPErrorPage* errorPage = nullptr;
   if (isInternal()) {
     if (addr.isPrivateAddress()) {
       errorPage = diagnosticErrorPage_.get();
     }
   }
   if (errorPage == nullptr) {
     errorPage = defaultErrorPage_.get();
   }
   return errorPage;
 }

virtual bool proxygen::HTTPSessionAcceptor::getHttp2PrioritiesEnabled ( )

inlinevirtual

Definition at line 108 of file HTTPSessionAcceptor.h.

References proxygen::HTTPAcceptor::accConfig_, and proxygen::AcceptorConfiguration::HTTP2PrioritiesEnabled.

Referenced by onNewConnection().

                                            {
     return accConfig_.HTTP2PrioritiesEnabled;
   }

HTTPSession::InfoCallback* proxygen::HTTPSessionAcceptor::getSessionInfoCallback ( )

inlineprotected

Definition at line 125 of file HTTPSessionAcceptor.h.

References onNewConnection(), sessionInfoCb_, and string.

                                                     {
     return sessionInfoCb_ ? sessionInfoCb_ : this;
   }

folly::AsyncSocket::UniquePtr proxygen::HTTPSessionAcceptor::makeNewAsyncSocket	(	folly::EventBase *	base,
		int	fd
	)

inlineoverrideprotectedvirtual

Reimplemented from wangle::Acceptor.

Definition at line 137 of file HTTPSessionAcceptor.h.

References dropIdleConnections().

                                                                     {
     return folly::AsyncSocket::UniquePtr(
       new folly::AsyncSocket(base, fd));
   }

virtual HTTPTransaction::Handler* proxygen::HTTPSessionAcceptor::newHandler	(	HTTPTransaction &	txn,
		HTTPMessage *	msg
	)

pure virtualnoexcept

Create a Handler for a new transaction. The transaction and HTTP message (request) are passed so the implementation can construct different handlers based on these. The transaction will be explicitly set on the handler later via setTransaction. The request message will be passed in onHeadersComplete.

Implemented in proxygen::HTTPServerAcceptor, and HTTPTargetSessionAcceptor.

Referenced by getCodecFactory(), and proxygen::SimpleController::getRequestHandler().

void proxygen::HTTPSessionAcceptor::onNewConnection	(	folly::AsyncTransportWrapper::UniquePtr	,
		const folly::SocketAddress *	,
		const std::string &	,
		wangle::SecureTransportType	,
		const wangle::TransportInfo &
	)

overrideprotectedvirtual

Invoked when a new connection is created. This is where application starts processing a new downstream connection.

NOTE: Application should add the new connection to downstreamConnectionManager so that it can be garbage collected after certain period of idleness.

Parameters

sock	the socket connected to the client
address	the address of the client
nextProtocolName	the name of the L6 or L7 protocol to be spoken on the connection, if known (e.g., from TLS NPN during secure connection setup), or an empty string if unknown
secureTransportType	the name of the secure transport type that was requested by the client.

Reimplemented from wangle::Acceptor.

Definition at line 58 of file HTTPSessionAcceptor.cpp.

References proxygen::HTTPAcceptor::accConfig_, wangle::ServerSocketConfig::bindAddress, codec, codecFactory_, folly::SocketAddress::describe(), proxygen::DOWNSTREAM, downstreamSessionStats_, proxygen::AcceptorConfiguration::egressSettings, getController(), getHttp2PrioritiesEnabled(), proxygen::HTTPAcceptor::getTransactionTimeoutSet(), proxygen::AcceptorConfiguration::initialReceiveWindow, folly::SocketAddress::isFamilyInet(), proxygen::kErrorUnsupportedScheme, proxygen::AcceptorConfiguration::maxConcurrentIncomingStreams, folly::gen::move, onSessionCreationError(), proxygen::AcceptorConfiguration::receiveSessionWindowSize, proxygen::AcceptorConfiguration::receiveStreamWindowSize, sessionInfoCb_, proxygen::HTTPSession::setEgressSettings(), proxygen::HTTPSession::setFlowControl(), proxygen::HTTPSession::setHTTP2PrioritiesEnabled(), proxygen::HTTPSession::setMaxConcurrentIncomingStreams(), proxygen::HTTPSession::setSessionStats(), proxygen::HTTPSessionBase::setWriteBufferLimit(), proxygen::HTTPDownstreamSession::startNow(), unknownSocketAddress_, and proxygen::AcceptorConfiguration::writeBufferLimit.

Referenced by getSessionInfoCallback(), and proxygen::HTTPServerAcceptor::onNewConnection().

                                       {
 
   unique_ptr<HTTPCodec> codec
       = codecFactory_->getCodec(
           nextProtocol,
           TransportDirection::DOWNSTREAM,
           // we assume if security protocol isn't empty, then it's TLS
           !sock->getSecurityProtocol().empty());
 
   if (!codec) {
     VLOG(2) << "codecFactory_ failed to provide codec";
     onSessionCreationError(ProxygenError::kErrorUnsupportedScheme);
     return;
   }
 
   auto controller = getController();
   SocketAddress localAddress;
   try {
     sock->getLocalAddress(&localAddress);
   } catch (...) {
     VLOG(3) << "couldn't get local address for socket";
     localAddress = unknownSocketAddress_;
   }
 
   // overwrite address if the socket has no IP, e.g. Unix domain socket
   if (!localAddress.isFamilyInet()) {
     if (accConfig_.bindAddress.isFamilyInet()) {
       localAddress = accConfig_.bindAddress;
     } else {
       localAddress = unknownSocketAddress_;
     }
     VLOG(4) << "set localAddress=" << localAddress.describe();
   }
 
   auto sessionInfoCb = sessionInfoCb_ ? sessionInfoCb_ : this;
   VLOG(4) << "Created new " << nextProtocol
           << " session for peer " << *peerAddress;
   HTTPDownstreamSession* session =
     new HTTPDownstreamSession(getTransactionTimeoutSet(), std::move(sock),
                               localAddress, *peerAddress,
                               controller, std::move(codec), tinfo,
                               sessionInfoCb);
   if (accConfig_.maxConcurrentIncomingStreams) {
     session->setMaxConcurrentIncomingStreams(
         accConfig_.maxConcurrentIncomingStreams);
   }
   session->setEgressSettings(accConfig_.egressSettings);
 
   // set HTTP2 priorities flag on session object
   auto HTTP2PrioritiesEnabled = getHttp2PrioritiesEnabled();
   session->setHTTP2PrioritiesEnabled(HTTP2PrioritiesEnabled);
 
   // set flow control parameters
   session->setFlowControl(accConfig_.initialReceiveWindow,
                           accConfig_.receiveStreamWindowSize,
                           accConfig_.receiveSessionWindowSize);
   if (accConfig_.writeBufferLimit > 0) {
     session->setWriteBufferLimit(accConfig_.writeBufferLimit);
   }
   session->setSessionStats(downstreamSessionStats_);
   Acceptor::addConnection(session);
   session->startNow();
 }

virtual void proxygen::HTTPSessionAcceptor::onSessionCreationError ( ProxygenError )

inlineprotectedvirtual

Reimplemented in HTTPTargetSessionAcceptor.

Definition at line 145 of file HTTPSessionAcceptor.h.

References HTTPSessionAcceptor(), and operator=().

Referenced by onNewConnection().

145 {}

HTTPSessionAcceptor& proxygen::HTTPSessionAcceptor::operator= ( const HTTPSessionAcceptor & )

privatedelete

Referenced by onSessionCreationError().

void proxygen::HTTPSessionAcceptor::setCodecFactory ( std::shared_ptr< HTTPCodecFactory > codecFactory )

inline

Set the codec factory for this session

Definition at line 79 of file HTTPSessionAcceptor.h.

References codecFactory_.

                                                                      {
     codecFactory_ = codecFactory;
   }

void proxygen::HTTPSessionAcceptor::setDefaultErrorPage ( std::unique_ptr< HTTPErrorPage > generator )

inline

Set the default error page generator.

Definition at line 40 of file HTTPSessionAcceptor.h.

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

                                                                    {
     defaultErrorPage_ = std::move(generator);
   }

void proxygen::HTTPSessionAcceptor::setDiagnosticErrorPage ( std::unique_ptr< HTTPErrorPage > generator )

inline

Set an alternate error page generator to use for internal clients.

Definition at line 54 of file HTTPSessionAcceptor.h.

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

                                                                       {
     diagnosticErrorPage_ = std::move(generator);
   }

void proxygen::HTTPSessionAcceptor::setSessionInfoCallback ( HTTPSession::InfoCallback * cb )

inline

Set an HTTPSession::InfoCallback to use for each session instead of the acceptor object.

Definition at line 104 of file HTTPSessionAcceptor.h.

References sessionInfoCb_.

                                                            {
     sessionInfoCb_ = cb;
   }

Member Data Documentation

std::shared_ptr<HTTPCodecFactory> proxygen::HTTPSessionAcceptor::codecFactory_ {}

private

Definition at line 157 of file HTTPSessionAcceptor.h.

Referenced by getCodecFactory(), HTTPSessionAcceptor(), onNewConnection(), and setCodecFactory().

std::unique_ptr<HTTPErrorPage> proxygen::HTTPSessionAcceptor::defaultErrorPage_

private

General-case error page generator

Definition at line 152 of file HTTPSessionAcceptor.h.

Referenced by getDefaultErrorPage(), getErrorPage(), and setDefaultErrorPage().

std::unique_ptr<HTTPErrorPage> proxygen::HTTPSessionAcceptor::diagnosticErrorPage_

private

Generator of more detailed error pages for internal clients

Definition at line 155 of file HTTPSessionAcceptor.h.

Referenced by getDiagnosticErrorPage(), getErrorPage(), and setDiagnosticErrorPage().

HTTPSessionStats* proxygen::HTTPSessionAcceptor::downstreamSessionStats_ {nullptr}

protected

Definition at line 123 of file HTTPSessionAcceptor.h.

Referenced by onNewConnection().

HTTPSession::InfoCallback* proxygen::HTTPSessionAcceptor::sessionInfoCb_ {nullptr}

private

Definition at line 161 of file HTTPSessionAcceptor.h.

Referenced by getSessionInfoCallback(), onNewConnection(), and setSessionInfoCallback().

SimpleController proxygen::HTTPSessionAcceptor::simpleController_

private

Definition at line 159 of file HTTPSessionAcceptor.h.

Referenced by getController().

const SocketAddress proxygen::HTTPSessionAcceptor::unknownSocketAddress_

staticprivate

0.0.0.0:0, a valid address to use if getsockname() or getpeername() fails

Definition at line 166 of file HTTPSessionAcceptor.h.

Referenced by onNewConnection().

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

proxygen/lib/http/session/HTTPSessionAcceptor.h
proxygen/lib/http/session/HTTPSessionAcceptor.cpp

Public Member Functions

Protected Member Functions

Protected Attributes

Private Member Functions

Private Attributes

Static Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation