proxygen: wangle::ServerAcceptor< Pipeline

#include <ServerBootstrap-inl.h>

Inheritance diagram for wangle::ServerAcceptor< Pipeline >:

Classes
class	ServerConnection

Public Member Functions
	ServerAcceptor (std::shared_ptr< AcceptPipelineFactory > acceptPipelineFactory, std::shared_ptr< PipelineFactory< Pipeline >> childPipelineFactory, const ServerSocketConfig &accConfig)

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

void	read (Context *, AcceptPipelineType conn) override

void	readEOF (Context *) override

void	readException (Context *, folly::exception_wrapper) override

void	onNewConnection (folly::AsyncTransportWrapper::UniquePtr transport, const folly::SocketAddress *clientAddr, const std::string &nextProtocolName, SecureTransportType secureTransportType, const TransportInfo &tinfo) override

void	acceptStopped () noexceptoverride

void	drainConnections (double pct) noexceptoverride

void	dropConnections (double pct) noexceptoverride

void	forceStop () noexceptoverride

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

void	onConnectionAdded (const ManagedConnection *) override

void	onConnectionRemoved (const ManagedConnection *) override

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

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

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 ()

void	dropAllConnections ()

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	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

Public Member Functions inherited from wangle::InboundHandler< AcceptPipelineType >
	~InboundHandler () override=default

virtual void	transportActive (Context *ctx)

virtual void	transportInactive (Context *ctx)

Public Member Functions inherited from wangle::HandlerBase< InboundHandlerContext< AcceptPipelineType > >
virtual	~HandlerBase ()=default

virtual void	attachPipeline (InboundHandlerContext< AcceptPipelineType > *)

virtual void	detachPipeline (InboundHandlerContext< AcceptPipelineType > *)

InboundHandlerContext< AcceptPipelineType > *	getContext ()

Private Attributes
std::shared_ptr< AcceptPipelineFactory >	acceptPipelineFactory_

std::shared_ptr< AcceptPipeline >	acceptPipeline_

std::shared_ptr< PipelineFactory< Pipeline > >	childPipelineFactory_

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

Public Types inherited from wangle::InboundHandler< AcceptPipelineType >
typedef AcceptPipelineType	rin

typedef AcceptPipelineType	rout

typedef folly::Unit	win

typedef folly::Unit	wout

typedef InboundHandlerContext< AcceptPipelineType >	Context

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

Static Public Attributes inherited from wangle::InboundHandler< AcceptPipelineType >
static const HandlerDir	dir

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

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

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	onEmpty (const wangle::ConnectionManager &cm) 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 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_

Detailed Description

template<typename Pipeline>
class wangle::ServerAcceptor< Pipeline >

Definition at line 65 of file ServerBootstrap-inl.h.

Constructor & Destructor Documentation

template<typename Pipeline >

wangle::ServerAcceptor< Pipeline >::ServerAcceptor	(	std::shared_ptr< AcceptPipelineFactory >	acceptPipelineFactory,
		std::shared_ptr< PipelineFactory< Pipeline >>	childPipelineFactory,
		const ServerSocketConfig &	accConfig
	)

inlineexplicit

Definition at line 116 of file ServerBootstrap-inl.h.

       : Acceptor(accConfig),
         acceptPipelineFactory_(acceptPipelineFactory),
         childPipelineFactory_(childPipelineFactory) {
   }

Member Function Documentation

template<typename Pipeline >

void wangle::ServerAcceptor< Pipeline >::acceptStopped ( )

inlineoverridevirtualnoexcept

acceptStopped() will be called when this AcceptCallback is removed from the AsyncServerSocket, or when the AsyncServerSocket is destroyed, whichever occurs first.

No more calls to connectionAccepted() or acceptError() will be made after acceptStopped() is invoked.

Reimplemented from wangle::Acceptor.

Definition at line 185 of file ServerBootstrap-inl.h.

References wangle::AcceptorException::ACCEPT_STOPPED, and wangle::Acceptor::acceptStopped().

                                          {
     auto ew = folly::make_exception_wrapper<AcceptorException>(
       AcceptorException::ExceptionType::ACCEPT_STOPPED,
       "graceful shutdown timeout");
 
     acceptPipeline_->readException(ew);
     Acceptor::acceptStopped();
   }

template<typename Pipeline >

void wangle::ServerAcceptor< Pipeline >::drainConnections ( double pctToDrain )

inlineoverridevirtualnoexcept

Drain defined percentage of connections.

Reimplemented from wangle::Acceptor.

Definition at line 194 of file ServerBootstrap-inl.h.

References wangle::AcceptorException::DRAIN_CONN_PCT, and wangle::Acceptor::drainConnections().

                                                       {
     auto ew = folly::make_exception_wrapper<AcceptorException>(
       AcceptorException::ExceptionType::DRAIN_CONN_PCT,
       "draining some connections", pct);
 
     acceptPipeline_->readException(ew);
     Acceptor::drainConnections(pct);
   }

template<typename Pipeline >

void wangle::ServerAcceptor< Pipeline >::dropConnections ( double pctToDrop )

inlineoverridevirtualnoexcept

Force-drop "pct" (0.0 to 1.0) of remaining client connections, regardless of whether they are busy or idle.

Note: unlike dropAllConnections(), this function can be called from any thread.

Reimplemented from wangle::Acceptor.

Definition at line 203 of file ServerBootstrap-inl.h.

References wangle::AcceptorException::DROP_CONN_PCT, and wangle::Acceptor::dropConnections().

                                                      {
     auto ew = folly::make_exception_wrapper<AcceptorException>(
       AcceptorException::ExceptionType::DROP_CONN_PCT,
       "dropping some connections", pct);
 
     acceptPipeline_->readException(ew);
     Acceptor::dropConnections(pct);
   }

template<typename Pipeline >

void wangle::ServerAcceptor< Pipeline >::forceStop ( )

inlineoverridevirtualnoexcept

Force the acceptor to drop all connections and stop processing.

This function may be called from any thread. The acceptor will not necessarily stop before this function returns: the stop will be scheduled to run in the acceptor's thread.

Reimplemented from wangle::Acceptor.

Definition at line 212 of file ServerBootstrap-inl.h.

References wangle::AcceptorException::FORCE_STOP, and wangle::Acceptor::forceStop().

                                      {
     auto ew = folly::make_exception_wrapper<AcceptorException>(
       AcceptorException::ExceptionType::FORCE_STOP,
       "hard shutdown timeout");
 
     acceptPipeline_->readException(ew);
     Acceptor::forceStop();
   }

template<typename Pipeline >

void wangle::ServerAcceptor< Pipeline >::init	(	folly::AsyncServerSocket *	serverSocket,
		folly::EventBase *	eventBase,
		SSLStats *	stats = `nullptr`
	)

inlineoverridevirtual

Initialize the Acceptor to run in the specified EventBase thread, receiving connections from the specified AsyncServerSocket.

This method will be called from the AsyncServerSocket's primary thread, not the specified EventBase thread.

Reimplemented from wangle::Acceptor.

Definition at line 125 of file ServerBootstrap-inl.h.

References wangle::Acceptor::init().

                                                 {
     Acceptor::init(serverSocket, eventBase, stats);
 
     acceptPipeline_ = acceptPipelineFactory_->newPipeline(this);
 
     if (childPipelineFactory_) {
       // This means a custom AcceptPipelineFactory was not passed in via
       // pipeline() and we're using the DefaultAcceptPipelineFactory.
       // Add the default inbound handler here.
       acceptPipeline_->addBack(this);
     }
     acceptPipeline_->finalize();
   }

template<typename Pipeline >

void wangle::ServerAcceptor< Pipeline >::onConnectionAdded ( const ManagedConnection * conn )

inlineoverridevirtual

Invoked when a connection is added to the ConnectionManager.

Reimplemented from wangle::Acceptor.

Definition at line 230 of file ServerBootstrap-inl.h.

References wangle::CONN_ADDED.

                                                             {
     acceptPipeline_->read(ConnEvent::CONN_ADDED);
   }

template<typename Pipeline >

void wangle::ServerAcceptor< Pipeline >::onConnectionRemoved ( const ManagedConnection * conn )

inlineoverridevirtual

Invoked when a connection is removed from the ConnectionManager.

Reimplemented from wangle::Acceptor.

Definition at line 234 of file ServerBootstrap-inl.h.

References wangle::CONN_REMOVED.

                                                               {
     acceptPipeline_->read(ConnEvent::CONN_REMOVED);
   }

template<typename Pipeline >

void wangle::ServerAcceptor< Pipeline >::onDataAvailable	(	std::shared_ptr< folly::AsyncUDPSocket >	socket,
		const folly::SocketAddress &	addr,
		std::unique_ptr< folly::IOBuf >	buf,
		bool	truncated
	)

inlineoverridevirtualnoexcept

Invoked when a new packet is received

Reimplemented from wangle::Acceptor.

Definition at line 222 of file ServerBootstrap-inl.h.

References addr, std::tr1::make_tuple(), and folly::netops::socket().

                                                  {
     acceptPipeline_->read(
         AcceptPipelineType(make_tuple(buf.release(), socket, addr)));
   }

template<typename Pipeline >

void wangle::ServerAcceptor< Pipeline >::onNewConnection	(	folly::AsyncTransportWrapper::UniquePtr	,
		const folly::SocketAddress *	,
		const std::string &	,
		SecureTransportType	,
		const TransportInfo &
	)

inlineoverridevirtual

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 174 of file ServerBootstrap-inl.h.

                                                             {
     ConnInfo connInfo = {transport.release(), clientAddr, nextProtocolName,
                          secureTransportType, tinfo};
     acceptPipeline_->read(connInfo);
   }

template<typename Pipeline >

void wangle::ServerAcceptor< Pipeline >::read	(	Context *	,
		AcceptPipelineType	conn
	)

inlineoverridevirtual

Implements wangle::InboundHandler< AcceptPipelineType >.

Definition at line 141 of file ServerBootstrap-inl.h.

References wangle::Acceptor::addConnection(), and folly::gen::move.

                                                         {
     if (conn.type() != typeid(ConnInfo&)) {
       return;
     }
 
     auto connInfo = boost::get<ConnInfo&>(conn);
     folly::AsyncTransportWrapper::UniquePtr transport(connInfo.sock);
 
     // Setup local and remote addresses
     auto tInfoPtr = std::make_shared<TransportInfo>(connInfo.tinfo);
     tInfoPtr->localAddr =
       std::make_shared<folly::SocketAddress>(accConfig_.bindAddress);
     transport->getLocalAddress(tInfoPtr->localAddr.get());
     tInfoPtr->remoteAddr =
       std::make_shared<folly::SocketAddress>(*connInfo.clientAddr);
     tInfoPtr->appProtocol =
       std::make_shared<std::string>(connInfo.nextProtoName);
 
     auto pipeline = childPipelineFactory_->newPipeline(
       std::shared_ptr<folly::AsyncTransportWrapper>(
         transport.release(), folly::DelayedDestruction::Destructor()));
     pipeline->setTransportInfo(tInfoPtr);
     auto connection = new ServerConnection(std::move(pipeline));
     Acceptor::addConnection(connection);
     connection->init();
   }

template<typename Pipeline >

void wangle::ServerAcceptor< Pipeline >::readEOF ( Context * )

inlineoverridevirtual

Reimplemented from wangle::InboundHandler< AcceptPipelineType >.

Definition at line 170 of file ServerBootstrap-inl.h.

170 {}

template<typename Pipeline >

void wangle::ServerAcceptor< Pipeline >::readException	(	Context *	,
		folly::exception_wrapper
	)

inlineoverridevirtual

Reimplemented from wangle::InboundHandler< AcceptPipelineType >.

Definition at line 171 of file ServerBootstrap-inl.h.

171 {}

template<typename Pipeline >

void wangle::ServerAcceptor< Pipeline >::sslConnectionError ( const folly::exception_wrapper & ex )

inlineoverridevirtual

Notification callback for SSL handshake failures.

Reimplemented from wangle::Acceptor.

Definition at line 238 of file ServerBootstrap-inl.h.

References wangle::Acceptor::sslConnectionError().

                                                                      {
     acceptPipeline_->readException(ex);
     Acceptor::sslConnectionError(ex);
   }

Member Data Documentation

template<typename Pipeline >

std::shared_ptr<AcceptPipeline> wangle::ServerAcceptor< Pipeline >::acceptPipeline_

private

Definition at line 245 of file ServerBootstrap-inl.h.

template<typename Pipeline >

std::shared_ptr<AcceptPipelineFactory> wangle::ServerAcceptor< Pipeline >::acceptPipelineFactory_

private

Definition at line 244 of file ServerBootstrap-inl.h.

template<typename Pipeline >

std::shared_ptr<PipelineFactory<Pipeline> > wangle::ServerAcceptor< Pipeline >::childPipelineFactory_

private

Definition at line 246 of file ServerBootstrap-inl.h.

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

proxygen/wangle/wangle/bootstrap/ServerBootstrap-inl.h

Classes

Public Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

template<typename Pipeline> class wangle::ServerAcceptor< Pipeline >

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation

template<typename Pipeline>
class wangle::ServerAcceptor< Pipeline >