proxygen: folly::DecoratedAsyncTransportWrapper< T

#include <DecoratedAsyncTransportWrapper.h>

Inheritance diagram for folly::DecoratedAsyncTransportWrapper< T >:

Public Member Functions
	DecoratedAsyncTransportWrapper (typename T::UniquePtr transport)

const AsyncTransportWrapper *	getWrappedTransport () const override

ReadCallback *	getReadCallback () const override

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

void	write (folly::AsyncTransportWrapper::WriteCallback callback, const void buf, size_t bytes, folly::WriteFlags flags=folly::WriteFlags::NONE) override

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

void	writev (folly::AsyncTransportWrapper::WriteCallback callback, const iovec vec, size_t bytes, folly::WriteFlags flags=folly::WriteFlags::NONE) 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

virtual const X509 *	getSelfCert () const

Public Member Functions inherited from folly::DelayedDestruction
virtual void	destroy ()

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
	~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 Attributes
T::UniquePtr	transport_

Additional Inherited Members
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

Detailed Description

template<class T>
class folly::DecoratedAsyncTransportWrapper< T >

Convenience class so that AsyncTransportWrapper can be decorated without having to redefine every single method.

Definition at line 27 of file DecoratedAsyncTransportWrapper.h.

Constructor & Destructor Documentation

template<class T>

folly::DecoratedAsyncTransportWrapper< T >::DecoratedAsyncTransportWrapper ( typename T::UniquePtr transport )

inlineexplicit

Definition at line 29 of file DecoratedAsyncTransportWrapper.h.

30 : transport_(std::move(transport)) {}

folly::gen::move

constexpr detail::Map< Move > move

Definition: Base-inl.h:2567

folly::DecoratedAsyncTransportWrapper::transport_

T::UniquePtr transport_

Definition: DecoratedAsyncTransportWrapper.h:203

template<class T>

folly::DecoratedAsyncTransportWrapper< T >::~DecoratedAsyncTransportWrapper ( )

inlineoverrideprotected

Definition at line 201 of file DecoratedAsyncTransportWrapper.h.

201 {}

Member Function Documentation

template<class T>

void folly::DecoratedAsyncTransportWrapper< T >::attachEventBase ( folly::EventBase * eventBase )

inlineoverridevirtual

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.

Implements folly::AsyncTransport.

Definition at line 75 of file DecoratedAsyncTransportWrapper.h.

                                                            {
     transport_->attachEventBase(eventBase);
   }

template<class T>

void folly::DecoratedAsyncTransportWrapper< T >::close ( )

inlineoverridevirtual

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 79 of file DecoratedAsyncTransportWrapper.h.

                         {
     transport_->close();
   }

template<class T>

void folly::DecoratedAsyncTransportWrapper< T >::closeNow ( )

inlineoverridevirtual

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 83 of file DecoratedAsyncTransportWrapper.h.

Referenced by folly::DecoratedAsyncTransportWrapper< folly::AsyncTransportWrapper >::closeWithReset().

                            {
     transport_->closeNow();
   }

template<class T>

void folly::DecoratedAsyncTransportWrapper< T >::closeWithReset ( )

inlineoverridevirtual

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 87 of file DecoratedAsyncTransportWrapper.h.

                                  {
     transport_->closeWithReset();
 
     // This will likely result in 2 closeNow() calls on the decorated transport,
     // but otherwise it is very easy to miss the derived class's closeNow().
     closeNow();
   }

template<class T>

bool folly::DecoratedAsyncTransportWrapper< T >::connecting ( ) const

inlineoverridevirtual

Determine if transport is connected to the endpoint

Returns: false iff the transport is connected, otherwise true

Implements folly::AsyncTransport.

Definition at line 95 of file DecoratedAsyncTransportWrapper.h.

                                    {
     return transport_->connecting();
   }

template<class T>

void folly::DecoratedAsyncTransportWrapper< T >::detachEventBase ( )

inlineoverridevirtual

Detach the transport from its EventBase.

This may only be called when the transport is idle and has no reads or writes pending. Once detached, the transport may not be used again until it is re-attached to a EventBase by calling attachEventBase().

This method must be called from the current EventBase's thread.

Implements folly::AsyncTransport.

Definition at line 99 of file DecoratedAsyncTransportWrapper.h.

                                   {
     transport_->detachEventBase();
   }

template<class T>

bool folly::DecoratedAsyncTransportWrapper< T >::error ( ) const

inlineoverridevirtual

Determine if an error has occurred with this transport.

Returns: true iff an error has occurred (not EOF).

Implements folly::AsyncTransport.

Definition at line 103 of file DecoratedAsyncTransportWrapper.h.

                               {
     return transport_->error();
   }

template<class T>

size_t folly::DecoratedAsyncTransportWrapper< T >::getAppBytesReceived ( ) const

inlineoverridevirtual

Implements folly::AsyncTransport.

Definition at line 107 of file DecoratedAsyncTransportWrapper.h.

                                               {
     return transport_->getAppBytesReceived();
   }

template<class T>

size_t folly::DecoratedAsyncTransportWrapper< T >::getAppBytesWritten ( ) const

inlineoverridevirtual

Implements folly::AsyncTransport.

Definition at line 111 of file DecoratedAsyncTransportWrapper.h.

                                              {
     return transport_->getAppBytesWritten();
   }

template<class T>

std::string folly::DecoratedAsyncTransportWrapper< T >::getApplicationProtocol ( ) const

inlineoverridevirtualnoexcept

Return the application protocol being used by the underlying transport protocol. This is useful for transports which are used to tunnel other protocols.

Reimplemented from folly::AsyncTransport.

Definition at line 175 of file DecoratedAsyncTransportWrapper.h.

                                                              {
     return transport_->getApplicationProtocol();
   }

template<class T>

folly::EventBase* folly::DecoratedAsyncTransportWrapper< T >::getEventBase ( ) const

inlineoverridevirtual

Implements folly::AsyncSocketBase.

Definition at line 70 of file DecoratedAsyncTransportWrapper.h.

                                                 {
     return transport_->getEventBase();
   }

template<class T>

void folly::DecoratedAsyncTransportWrapper< T >::getLocalAddress ( folly::SocketAddress * address ) const

inlineoverridevirtual

Get the address of the local endpoint of this transport.

This function may throw AsyncSocketException on error.

Parameters

address The local address will be stored in the specified SocketAddress.

Implements folly::AsyncTransport.

Definition at line 115 of file DecoratedAsyncTransportWrapper.h.

                                                                    {
     return transport_->getLocalAddress(address);
   }

template<class T>

void folly::DecoratedAsyncTransportWrapper< T >::getPeerAddress ( folly::SocketAddress * address ) const

inlineoverridevirtual

Get the address of the remote endpoint to which this transport is connected.

This function may throw AsyncSocketException on error.

Parameters

address The remote endpoint's address will be stored in the specified SocketAddress.

Implements folly::AsyncTransport.

Definition at line 119 of file DecoratedAsyncTransportWrapper.h.

                                                                   {
     return transport_->getPeerAddress(address);
   }

template<class T>

folly::ssl::X509UniquePtr folly::DecoratedAsyncTransportWrapper< T >::getPeerCert ( ) const

inlineoverridevirtual

Get the certificate used to authenticate the peer.

Reimplemented from folly::AsyncTransport.

Definition at line 123 of file DecoratedAsyncTransportWrapper.h.

                                                      {
     return transport_->getPeerCert();
   }

template<class T>

const AsyncTransportCertificate* folly::DecoratedAsyncTransportWrapper< T >::getPeerCertificate ( ) const

inlineoverridevirtual

Get the peer certificate information if any

Reimplemented from folly::AsyncTransport.

Definition at line 192 of file DecoratedAsyncTransportWrapper.h.

                                                                        {
     return transport_->getPeerCertificate();
   }

template<class T>

size_t folly::DecoratedAsyncTransportWrapper< T >::getRawBytesReceived ( ) const

inlineoverridevirtual

Implements folly::AsyncTransport.

Definition at line 127 of file DecoratedAsyncTransportWrapper.h.

                                               {
     return transport_->getRawBytesReceived();
   }

template<class T>

size_t folly::DecoratedAsyncTransportWrapper< T >::getRawBytesWritten ( ) const

inlineoverridevirtual

Implements folly::AsyncTransport.

Definition at line 131 of file DecoratedAsyncTransportWrapper.h.

                                              {
     return transport_->getRawBytesWritten();
   }

template<class T>

ReadCallback* folly::DecoratedAsyncTransportWrapper< T >::getReadCallback ( ) const

inlineoverridevirtual

Implements folly::AsyncTransportWrapper.

Definition at line 37 of file DecoratedAsyncTransportWrapper.h.

                                                  {
     return transport_->getReadCallback();
   }

template<class T>

std::string folly::DecoratedAsyncTransportWrapper< T >::getSecurityProtocol ( ) const

inlineoverridevirtual

Returns the name of the security protocol being used.

Reimplemented from folly::AsyncTransport.

Definition at line 179 of file DecoratedAsyncTransportWrapper.h.

                                                  {
     return transport_->getSecurityProtocol();
   }

template<class T>

const AsyncTransportCertificate* folly::DecoratedAsyncTransportWrapper< T >::getSelfCertificate ( ) const

inlineoverridevirtual

Get the certificate information of this transport, if any

Reimplemented from folly::AsyncTransport.

Definition at line 196 of file DecoratedAsyncTransportWrapper.h.

                                                                        {
     return transport_->getSelfCertificate();
   }

template<class T>

uint32_t folly::DecoratedAsyncTransportWrapper< T >::getSendTimeout ( ) const

inlineoverridevirtual

Get the send timeout.

Returns: Returns the current send timeout, in milliseconds. A return value of 0 indicates that no timeout is set.

Implements folly::AsyncTransport.

Definition at line 135 of file DecoratedAsyncTransportWrapper.h.

                                            {
     return transport_->getSendTimeout();
   }

template<class T>

const AsyncTransportWrapper* folly::DecoratedAsyncTransportWrapper< T >::getWrappedTransport ( ) const

inlineoverridevirtual

The transport wrapper may wrap another transport. This returns the transport that is wrapped. It returns nullptr if there is no wrapped transport.

Reimplemented from folly::AsyncTransportWrapper.

Definition at line 32 of file DecoratedAsyncTransportWrapper.h.

                                                                     {
     return transport_.get();
   }

template<class T>

bool folly::DecoratedAsyncTransportWrapper< T >::good ( ) const

inlineoverridevirtual

Determine if transport is open and ready to read or write.

Note that this function returns false on EOF; you must also call error() to distinguish between an EOF and an error.

Returns: true iff the transport is open and ready, false otherwise.

Implements folly::AsyncTransport.

Definition at line 139 of file DecoratedAsyncTransportWrapper.h.

                              {
     return transport_->good();
   }

template<class T>

bool folly::DecoratedAsyncTransportWrapper< T >::isDetachable ( ) const

inlineoverridevirtual

Determine if the transport can be detached.

This method must be called from the current EventBase's thread.

Implements folly::AsyncTransport.

Definition at line 143 of file DecoratedAsyncTransportWrapper.h.

                                      {
     return transport_->isDetachable();
   }

template<class T>

bool folly::DecoratedAsyncTransportWrapper< T >::isEorTrackingEnabled ( ) const

inlineoverridevirtual

Returns: True iff end of record tracking is enabled

Implements folly::AsyncTransport.

Definition at line 147 of file DecoratedAsyncTransportWrapper.h.

                                              {
     return transport_->isEorTrackingEnabled();
   }

template<class T>

bool folly::DecoratedAsyncTransportWrapper< T >::isReplaySafe ( ) const

inlineoverridevirtual

False if the transport does not have replay protection, but will in the future.

Reimplemented from folly::AsyncTransport.

Definition at line 183 of file DecoratedAsyncTransportWrapper.h.

                                      {
     return transport_->isReplaySafe();
   }

template<class T>

bool folly::DecoratedAsyncTransportWrapper< T >::readable ( ) const

inlineoverridevirtual

Determine if the transport is readable or not.

Returns: true iff the transport is readable, false otherwise.

Implements folly::AsyncTransport.

Definition at line 151 of file DecoratedAsyncTransportWrapper.h.

                                  {
     return transport_->readable();
   }

template<class T>

void folly::DecoratedAsyncTransportWrapper< T >::setEorTracking ( bool track )

inlineoverridevirtual

Implements folly::AsyncTransport.

Definition at line 159 of file DecoratedAsyncTransportWrapper.h.

                                            {
     return transport_->setEorTracking(track);
   }

template<class T>

void folly::DecoratedAsyncTransportWrapper< T >::setReadCB ( folly::AsyncTransportWrapper::ReadCallback * callback )

inlineoverridevirtual

Implements folly::AsyncTransportWrapper.

Definition at line 41 of file DecoratedAsyncTransportWrapper.h.

                                                                  {
     transport_->setReadCB(callback);
   }

template<class T>

void folly::DecoratedAsyncTransportWrapper< T >::setReplaySafetyCallback ( folly::AsyncTransport::ReplaySafetyCallback * callback )

inlineoverridevirtual

Set the ReplaySafeCallback on this transport.

This should only be called if isReplaySafe() returns false.

Reimplemented from folly::AsyncTransport.

Definition at line 187 of file DecoratedAsyncTransportWrapper.h.

                                                                   {
     transport_->setReplaySafetyCallback(callback);
   }

template<class T>

void folly::DecoratedAsyncTransportWrapper< T >::setSendTimeout ( uint32_t milliseconds )

inlineoverridevirtual

Set the send timeout.

If write requests do not make any progress for more than the specified number of milliseconds, fail all pending writes and close the transport.

If write requests are currently pending when setSendTimeout() is called, the timeout interval is immediately restarted using the new value.

Parameters

milliseconds The timeout duration, in milliseconds. If 0, no timeout will be used.

Implements folly::AsyncTransport.

Definition at line 163 of file DecoratedAsyncTransportWrapper.h.

                                                      {
     transport_->setSendTimeout(timeoutInMs);
   }

template<class T>

void folly::DecoratedAsyncTransportWrapper< T >::shutdownWrite ( )

inlineoverridevirtual

Perform a half-shutdown of the write side of the transport.

The caller should not make any more calls to write() or writev() after shutdownWrite() is called. Any future write attempts will fail immediately.

Not all transport types support half-shutdown. If the underlying transport does not support half-shutdown, it will fully shutdown both the read and write sides of the transport. (Fully shutting down the socket is better than doing nothing at all, since the caller may rely on the shutdownWrite() call to notify the other end of the connection that no more data can be read.)

If there is pending data still waiting to be written on the transport, the actual shutdown will be delayed until the pending data has been written.

Note: There is no corresponding shutdownRead() equivalent. Simply uninstall the read callback if you wish to stop reading. (On TCP sockets at least, shutting down the read side of the socket is a no-op anyway.)

Implements folly::AsyncTransport.

Definition at line 167 of file DecoratedAsyncTransportWrapper.h.

                                 {
     transport_->shutdownWrite();
   }

template<class T>

void folly::DecoratedAsyncTransportWrapper< T >::shutdownWriteNow ( )

inlineoverridevirtual

Perform a half-shutdown of the write side of the transport.

shutdownWriteNow() is identical to shutdownWrite(), except that it immediately performs the shutdown, rather than waiting for pending writes to complete. Any pending write requests will be immediately failed when shutdownWriteNow() is called.

Implements folly::AsyncTransport.

Definition at line 171 of file DecoratedAsyncTransportWrapper.h.

                                    {
     transport_->shutdownWriteNow();
   }

template<class T>

bool folly::DecoratedAsyncTransportWrapper< T >::writable ( ) const

inlineoverridevirtual

Determine if the transport is writable or not.

Returns: true iff the transport is writable, false otherwise.

Reimplemented from folly::AsyncTransport.

Definition at line 155 of file DecoratedAsyncTransportWrapper.h.

                                  {
     return transport_->writable();
   }

template<class T>

void folly::DecoratedAsyncTransportWrapper< T >::write	(	folly::AsyncTransportWrapper::WriteCallback *	callback,
		const void *	buf,
		size_t	bytes,
		folly::WriteFlags	flags = `folly::WriteFlags::NONE`
	)

inlineoverridevirtual

If you supply a non-null WriteCallback, exactly one of writeSuccess() or writeErr() will be invoked when the write completes. If you supply the same WriteCallback object for multiple write() calls, it will be invoked exactly once per call. The only way to cancel outstanding write requests is to close the socket (e.g., with closeNow() or shutdownWriteNow()). When closing the socket this way, writeErr() will still be invoked once for each outstanding write operation.

Implements folly::AsyncTransportWrapper.

Reimplemented in folly::WriteChainAsyncTransportWrapper< T >, and folly::WriteChainAsyncTransportWrapper< folly::AsyncTransportWrapper >.

Definition at line 46 of file DecoratedAsyncTransportWrapper.h.

                                                             {
     transport_->write(callback, buf, bytes, flags);
   }

template<class T>

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

inlineoverridevirtual

Implements folly::AsyncTransportWrapper.

Reimplemented in folly::WriteChainAsyncTransportWrapper< T >, and folly::WriteChainAsyncTransportWrapper< folly::AsyncTransportWrapper >.

Definition at line 54 of file DecoratedAsyncTransportWrapper.h.

                                                             {
     transport_->writeChain(callback, std::move(buf), flags);
   }

template<class T>

void folly::DecoratedAsyncTransportWrapper< T >::writev	(	folly::AsyncTransportWrapper::WriteCallback *	callback,
		const iovec *	vec,
		size_t	count,
		folly::WriteFlags	flags = `folly::WriteFlags::NONE`
	)

inlineoverridevirtual

Implements folly::AsyncTransportWrapper.

Reimplemented in folly::WriteChainAsyncTransportWrapper< T >, and folly::WriteChainAsyncTransportWrapper< folly::AsyncTransportWrapper >.

Definition at line 61 of file DecoratedAsyncTransportWrapper.h.

                                                             {
     transport_->writev(callback, vec, bytes, flags);
   }

Member Data Documentation

template<class T>

T::UniquePtr folly::DecoratedAsyncTransportWrapper< T >::transport_

protected

Definition at line 203 of file DecoratedAsyncTransportWrapper.h.

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

proxygen/folly/folly/io/async/DecoratedAsyncTransportWrapper.h

Public Member Functions

Protected Member Functions

Protected Attributes

Additional Inherited Members

Detailed Description

template<class T> class folly::DecoratedAsyncTransportWrapper< T >

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation

template<class T>
class folly::DecoratedAsyncTransportWrapper< T >