proxygen: fizz::server::AsyncFizzServerT< SM

#include <AsyncFizzServer.h>

Inheritance diagram for fizz::server::AsyncFizzServerT< SM >:

Classes
class	ActionMoveVisitor

class	HandshakeCallback

Public Types
using	UniquePtr = std::unique_ptr< AsyncFizzServerT, folly::DelayedDestruction::Destructor >

Public Types inherited from fizz::AsyncFizzBase
using	UniquePtr = std::unique_ptr< AsyncFizzBase, folly::DelayedDestruction::Destructor >

using	ReadCallback = folly::AsyncTransportWrapper::ReadCallback

Public Types inherited from folly::AsyncTransportWrapper
using	UniquePtr = std::unique_ptr< AsyncTransportWrapper, Destructor >

using	ReadCallback = AsyncReader::ReadCallback

using	WriteCallback = AsyncWriter::WriteCallback

Public Types inherited from folly::AsyncTransport
typedef std::unique_ptr< AsyncTransport, Destructor >	UniquePtr

Public Member Functions
	AsyncFizzServerT (folly::AsyncTransportWrapper::UniquePtr socket, const std::shared_ptr< FizzServerContext > &fizzContext, const std::shared_ptr< ServerExtensions > &extensions=nullptr)

virtual void	accept (HandshakeCallback *callback)

bool	good () const override

bool	readable () const override

bool	connecting () const override

bool	error () const override

bool	isDetachable () const override

void	attachEventBase (folly::EventBase *evb) override

folly::ssl::X509UniquePtr	getPeerCert () const override

const X509 *	getSelfCert () const override

bool	isReplaySafe () const override

void	setReplaySafetyCallback (folly::AsyncTransport::ReplaySafetyCallback *callback) override

std::string	getApplicationProtocol () const noexceptoverride

void	close () override

void	closeWithReset () override

void	closeNow () override

const State &	getState () const

folly::Optional< CipherSuite >	getCipher () const override

std::vector< SignatureScheme >	getSupportedSigSchemes () const override

Buf	getEkm (folly::StringPiece label, const Buf &hashedContext, uint16_t length) const override

virtual Buf	getEarlyEkm (folly::StringPiece label, const Buf &hashedContext, uint16_t length) const

const Cert *	getPeerCertificate () const override

const Cert *	getSelfCertificate () const override

Public Member Functions inherited from fizz::AsyncFizzBase
	AsyncFizzBase (folly::AsyncTransportWrapper::UniquePtr transport)

	~AsyncFizzBase () override

ReadCallback *	getReadCallback () const override

void	setReadCB (ReadCallback *callback) override

void	writeChain (folly::AsyncTransportWrapper::WriteCallback *callback, std::unique_ptr< folly::IOBuf > &&buf, folly::WriteFlags flags=folly::WriteFlags::NONE) override

size_t	getAppBytesWritten () const override

size_t	getAppBytesReceived () const override

void	destroy () override

std::string	getSecurityProtocol () const override

void	attachTimeoutManager (folly::TimeoutManager *manager)

void	detachTimeoutManager ()

void	detachEventBase () override

Public Member Functions inherited from folly::WriteChainAsyncTransportWrapper< folly::AsyncTransportWrapper >
void	write (folly::AsyncTransportWrapper::WriteCallback callback, const void buf, size_t bytes, folly::WriteFlags flags=folly::WriteFlags::NONE) override

void	writev (folly::AsyncTransportWrapper::WriteCallback callback, const iovec vec, size_t count, folly::WriteFlags flags=folly::WriteFlags::NONE) override

Public Member Functions inherited from folly::DecoratedAsyncTransportWrapper< folly::AsyncTransportWrapper >
	DecoratedAsyncTransportWrapper (typename folly::AsyncTransportWrapper::UniquePtr transport)

const AsyncTransportWrapper *	getWrappedTransport () const override

ReadCallback *	getReadCallback () const override

void	setReadCB (folly::AsyncTransportWrapper::ReadCallback *callback) override

folly::EventBase *	getEventBase () const override

void	attachEventBase (folly::EventBase *eventBase) override

void	close () override

void	closeNow () override

void	closeWithReset () override

bool	connecting () const override

void	detachEventBase () override

bool	error () const override

size_t	getAppBytesReceived () const override

size_t	getAppBytesWritten () const override

void	getLocalAddress (folly::SocketAddress *address) const override

void	getPeerAddress (folly::SocketAddress *address) const override

folly::ssl::X509UniquePtr	getPeerCert () const override

size_t	getRawBytesReceived () const override

size_t	getRawBytesWritten () const override

uint32_t	getSendTimeout () const override

bool	good () const override

bool	isDetachable () const override

bool	isEorTrackingEnabled () const override

bool	readable () const override

bool	writable () const override

void	setEorTracking (bool track) override

void	setSendTimeout (uint32_t timeoutInMs) override

void	shutdownWrite () override

void	shutdownWriteNow () override

std::string	getApplicationProtocol () const noexceptoverride

std::string	getSecurityProtocol () const override

bool	isReplaySafe () const override

void	setReplaySafetyCallback (folly::AsyncTransport::ReplaySafetyCallback *callback) override

const AsyncTransportCertificate *	getPeerCertificate () const override

const AsyncTransportCertificate *	getSelfCertificate () const override

Public Member Functions inherited from folly::AsyncTransportWrapper
template<class T >
const T *	getUnderlyingTransport () const

template<class T >
T *	getUnderlyingTransport ()

Public Member Functions inherited from folly::AsyncTransport
virtual bool	isPending () const

SocketAddress	getLocalAddress () const

void	getAddress (SocketAddress *address) const override

SocketAddress	getPeerAddress () const

Public Member Functions inherited from folly::DelayedDestruction
bool	getDestroyPending () const

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

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

Protected Member Functions
void	writeAppData (folly::AsyncTransportWrapper::WriteCallback *callback, std::unique_ptr< folly::IOBuf > &&buf, folly::WriteFlags flags=folly::WriteFlags::NONE) override

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

void	transportDataAvailable () override

Protected Member Functions inherited from fizz::AsyncFizzBase
virtual void	startTransportReads ()

virtual void	startHandshakeTimeout (std::chrono::milliseconds)

virtual void	cancelHandshakeTimeout ()

virtual void	deliverAppData (std::unique_ptr< folly::IOBuf > buf)

virtual void	deliverError (const folly::AsyncSocketException &ex, bool closeTransport=true)

Protected Member Functions inherited from folly::DecoratedAsyncTransportWrapper< folly::AsyncTransportWrapper >
	~DecoratedAsyncTransportWrapper () override

Protected Member Functions inherited from folly::AsyncTransport
	~AsyncTransport () override=default

Protected Member Functions inherited from folly::DelayedDestruction
	~DelayedDestruction () override=default

	DelayedDestruction ()

Protected Member Functions inherited from folly::DelayedDestructionBase
	DelayedDestructionBase ()

uint32_t	getDestructorGuardCount () const

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

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

Protected Member Functions inherited from folly::AsyncWriter::WriteCallback
virtual	~WriteCallback ()=default

Private Member Functions
void	deliverAllErrors (const folly::AsyncSocketException &ex, bool closeTransport=true)

void	deliverHandshakeError (folly::exception_wrapper ex)

Private Attributes
HandshakeCallback *	handshakeCallback_ {nullptr}

std::shared_ptr< FizzServerContext >	fizzContext_

std::shared_ptr< ServerExtensions >	extensions_

State	state_

ActionMoveVisitor	visitor_

FizzServer< ActionMoveVisitor, SM >	fizzServer_

Additional Inherited Members
Protected Attributes inherited from fizz::AsyncFizzBase
folly::IOBufQueue	transportReadBuf_ {folly::IOBufQueue::cacheChainLength()}

Protected Attributes inherited from folly::DecoratedAsyncTransportWrapper< folly::AsyncTransportWrapper >
folly::AsyncTransportWrapper::UniquePtr	transport_

Detailed Description

template<typename SM>
class fizz::server::AsyncFizzServerT< SM >

Definition at line 21 of file AsyncFizzServer.h.

Member Typedef Documentation

template<typename SM>

using fizz::server::AsyncFizzServerT< SM >::UniquePtr = std::unique_ptr<AsyncFizzServerT, folly::DelayedDestruction::Destructor>

Definition at line 38 of file AsyncFizzServer.h.

Constructor & Destructor Documentation

template<typename SM >

fizz::server::AsyncFizzServerT< SM >::AsyncFizzServerT	(	folly::AsyncTransportWrapper::UniquePtr	socket,
		const std::shared_ptr< FizzServerContext > &	fizzContext,
		const std::shared_ptr< ServerExtensions > &	extensions = `nullptr`
	)

Definition at line 15 of file AsyncFizzServer-inl.h.

     : AsyncFizzBase(std::move(socket)),
       fizzContext_(fizzContext),
       extensions_(extensions),
       visitor_(*this),
       fizzServer_(state_, transportReadBuf_, visitor_, this) {}

Member Function Documentation

template<typename SM >

void fizz::server::AsyncFizzServerT< SM >::accept ( HandshakeCallback * callback )

virtual

Definition at line 26 of file AsyncFizzServer-inl.h.

References fizz::server::AsyncFizzServerT< SM >::extensions_, fizz::server::AsyncFizzServerT< SM >::fizzContext_, fizz::server::AsyncFizzServerT< SM >::fizzServer_, fizz::server::AsyncFizzServerT< SM >::handshakeCallback_, fizz::AsyncFizzBase::startTransportReads(), and folly::DecoratedAsyncTransportWrapper< folly::AsyncTransportWrapper >::transport_.

                                                              {
   handshakeCallback_ = callback;
 
   fizzServer_.accept(transport_->getEventBase(), fizzContext_, extensions_);
   startTransportReads();
 }

template<typename SM >

void fizz::server::AsyncFizzServerT< SM >::attachEventBase ( folly::EventBase * eventBase )

overridevirtual

Attach the transport to a EventBase.

This may only be called if the transport is not currently attached to a EventBase (by an earlier call to detachEventBase()).

This method must be invoked in the EventBase's thread.

Reimplemented from fizz::AsyncFizzBase.

Definition at line 59 of file AsyncFizzServer-inl.h.

References fizz::AsyncFizzBase::attachEventBase(), fizz::server::State::executor(), and fizz::server::AsyncFizzServerT< SM >::state_.

                                                               {
   state_.executor() = evb;
   AsyncFizzBase::attachEventBase(evb);
 }

template<typename SM >

void fizz::server::AsyncFizzServerT< SM >::close ( )

overridevirtual

Close the transport.

This gracefully closes the transport, waiting for all pending write requests to complete before actually closing the underlying transport.

If a read callback is set, readEOF() will be called immediately. If there are outstanding write requests, the close will be delayed until all remaining writes have completed. No new writes may be started after close() has been called.

Implements folly::AsyncTransport.

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

References fizz::server::AsyncFizzServerT< SM >::deliverAllErrors(), folly::AsyncSocketException::END_OF_FILE, fizz::server::AsyncFizzServerT< SM >::fizzServer_, and folly::DecoratedAsyncTransportWrapper< folly::AsyncTransportWrapper >::transport_.

                                  {
   if (transport_->good()) {
     fizzServer_.appClose();
   } else {
     DelayedDestruction::DestructorGuard dg(this);
     folly::AsyncSocketException ase(
         folly::AsyncSocketException::END_OF_FILE, "socket closed locally");
     deliverAllErrors(ase, false);
     transport_->close();
   }
 }

template<typename SM >

void fizz::server::AsyncFizzServerT< SM >::closeNow ( )

overridevirtual

Close the transport immediately.

This closes the transport immediately, dropping any outstanding data waiting to be written.

If a read callback is set, readEOF() will be called immediately. If there are outstanding write requests, these requests will be aborted and writeError() will be invoked immediately on all outstanding write callbacks.

Implements folly::AsyncTransport.

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

                                     {
   DelayedDestruction::DestructorGuard dg(this);
   if (transport_->good()) {
     fizzServer_.appClose();
   }
   folly::AsyncSocketException ase(
       folly::AsyncSocketException::END_OF_FILE, "socket closed locally");
   deliverAllErrors(ase, false);
   transport_->closeNow();
 }

template<typename SM >

void fizz::server::AsyncFizzServerT< SM >::closeWithReset ( )

overridevirtual

Reset the transport immediately.

This closes the transport immediately, sending a reset to the remote peer if possible to indicate abnormal shutdown.

Note that not all subclasses implement this reset functionality: some subclasses may treat reset() the same as closeNow(). Subclasses that use TCP transports should terminate the connection with a TCP reset.

Reimplemented from folly::AsyncTransport.

Definition at line 129 of file AsyncFizzServer-inl.h.

                                           {
   DelayedDestruction::DestructorGuard dg(this);
   if (transport_->good()) {
     fizzServer_.appClose();
   }
   folly::AsyncSocketException ase(
       folly::AsyncSocketException::END_OF_FILE, "socket closed locally");
   deliverAllErrors(ase, false);
   transport_->closeWithReset();
 }

template<typename SM >

bool fizz::server::AsyncFizzServerT< SM >::connecting ( ) const

overridevirtual

Determine if transport is connected to the endpoint

Returns: false iff the transport is connected, otherwise true

Classes

Public Types

Public Member Functions

Protected Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

template<typename SM> class fizz::server::AsyncFizzServerT< SM >

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation

template<typename SM>
class fizz::server::AsyncFizzServerT< SM >