wangle::AsyncSocketHandler Class Reference

#include <AsyncSocketHandler.h>

Inheritance diagram for wangle::AsyncSocketHandler:

Classes
class	WriteCallback

Public Member Functions
	AsyncSocketHandler (std::shared_ptr< folly::AsyncTransportWrapper > socket)
	AsyncSocketHandler (AsyncSocketHandler &&)=default
	~AsyncSocketHandler () override
void	attachReadCallback ()
void	detachReadCallback ()
void	attachEventBase (folly::EventBase *eventBase)
void	detachEventBase ()
void	transportActive (Context *ctx) override
void	transportInactive (Context *ctx) override
void	detachPipeline (Context *) override
folly::Future< folly::Unit >	write (Context *ctx, std::unique_ptr< folly::IOBuf > buf) override
folly::Future< folly::Unit >	writeException (Context *ctx, folly::exception_wrapper) override
folly::Future< folly::Unit >	close (Context *ctx) override
void	readEOF (Context *ctx) override
void	getReadBuffer (void **bufReturn, size_t *lenReturn) override
void	readDataAvailable (size_t len) noexceptoverride
void	readEOF () noexceptoverride
void	readErr (const folly::AsyncSocketException &ex) noexceptoverride
Public Member Functions inherited from wangle::HandlerAdapter< R, W >
void	read (Context *ctx, R msg) override
folly::Future< folly::Unit >	write (Context *ctx, W msg) override
Public Member Functions inherited from wangle::Handler< R, R, W, W >
	~Handler () override=default
virtual void	read (Context *ctx, Rmsg)=0
virtual void	readEOF (Context *ctx)
virtual void	readException (Context *ctx, folly::exception_wrapper e)
virtual void	transportActive (Context *ctx)
virtual void	transportInactive (Context *ctx)
virtual folly::Future< folly::Unit >	write (Context *ctx, Wmsg)=0
virtual folly::Future< folly::Unit >	writeException (Context *ctx, folly::exception_wrapper e)
virtual folly::Future< folly::Unit >	close (Context *ctx)
Public Member Functions inherited from wangle::HandlerBase< HandlerContext< R, W > >
virtual	~HandlerBase ()=default
virtual void	attachPipeline (HandlerContext< R, W > *)
virtual void	detachPipeline (HandlerContext< R, W > *)
HandlerContext< R, W > *	getContext ()
Public Member Functions inherited from folly::AsyncReader::ReadCallback
virtual	~ReadCallback ()=default
virtual bool	isBufferMovable () noexcept
virtual size_t	maxBufferSize () const
virtual void	readBufferAvailable (std::unique_ptr< IOBuf >) noexcept

Private Member Functions
void	refreshTimeout ()
folly::Future< folly::Unit >	shutdown (Context *ctx, bool closeWithReset)

Private Attributes
folly::IOBufQueue	bufQueue_ {folly::IOBufQueue::cacheChainLength()}
std::shared_ptr< folly::AsyncTransportWrapper >	socket_ {nullptr}
bool	firedInactive_ {false}
bool	pipelineDeleted_ {false}

Additional Inherited Members
Public Types inherited from wangle::HandlerAdapter< R, W >
typedef Handler< R, R, W, W >::Context	Context
Public Types inherited from wangle::Handler< R, R, W, W >
typedef R	rin
typedef R	rout
typedef W	win
typedef W	wout
typedef HandlerContext< R, W >	Context
Static Public Attributes inherited from wangle::Handler< R, R, W, W >
static const HandlerDir	dir

Detailed Description

Definition at line 29 of file AsyncSocketHandler.h.

Constructor & Destructor Documentation

wangle::AsyncSocketHandler::AsyncSocketHandler ( std::shared_ptr< folly::AsyncTransportWrapper >  socket )

inlineexplicit

Definition at line 33 of file AsyncSocketHandler.h.

    : socket_(std::move(socket)) {}

wangle::AsyncSocketHandler::AsyncSocketHandler ( AsyncSocketHandler &&  )

default

wangle::AsyncSocketHandler::~AsyncSocketHandler ( )

inlineoverride

Definition at line 39 of file AsyncSocketHandler.h.

References detachReadCallback(), folly::gen::move, s, and socket_.

                                 {
    detachReadCallback();

    if (socket_) {
      auto evb = socket_->getEventBase();
      if (evb) {
        evb->runImmediatelyOrRunInEventBaseThreadAndWait(
            [s = std::move(socket_)]() mutable {
              s.reset();
            });
      }
    }
  }

Member Function Documentation

void wangle::AsyncSocketHandler::attachEventBase ( folly::EventBase *  eventBase )

inline

Definition at line 68 of file AsyncSocketHandler.h.

References socket_.

                                                  {
    if (eventBase && !socket_->getEventBase()) {
      socket_->attachEventBase(eventBase);
    }
  }

void wangle::AsyncSocketHandler::attachReadCallback ( )

inline

Definition at line 53 of file AsyncSocketHandler.h.

References socket_.

Referenced by transportActive().

                            {
    socket_->setReadCB(socket_->good() ? this : nullptr);
  }

folly::Future<folly::Unit> wangle::AsyncSocketHandler::close ( Context *  ctx )

inlineoverride

Definition at line 125 of file AsyncSocketHandler.h.

References folly::isSet(), folly::makeFuture(), shutdown(), socket_, and folly::WRITE_SHUTDOWN.

                                                      {
    bool shutdownWriteOnly = isSet(ctx->getWriteFlags(),
                                   folly::WriteFlags::WRITE_SHUTDOWN);
    if (shutdownWriteOnly) {
      socket_->shutdownWrite();
      return folly::makeFuture();
    } else {
      return shutdown(ctx, false);
    }
  }

void wangle::AsyncSocketHandler::detachEventBase ( )

inline

Definition at line 74 of file AsyncSocketHandler.h.

References detachReadCallback(), and socket_.

                         {
    detachReadCallback();
    if (socket_->getEventBase()) {
      socket_->detachEventBase();
    }
  }

void wangle::AsyncSocketHandler::detachPipeline ( Context *  )

inlineoverride

Definition at line 95 of file AsyncSocketHandler.h.

References detachReadCallback().

                                         {
    detachReadCallback();
  }

void wangle::AsyncSocketHandler::detachReadCallback ( )

inline

Definition at line 57 of file AsyncSocketHandler.h.

References firedInactive_, wangle::HandlerBase< HandlerContext< R, W > >::getContext(), and socket_.

Referenced by detachEventBase(), detachPipeline(), shutdown(), transportInactive(), and ~AsyncSocketHandler().

                            {
    if (socket_ && socket_->getReadCallback() == this) {
      socket_->setReadCB(nullptr);
    }
    auto ctx = getContext();
    if (ctx && !firedInactive_) {
      firedInactive_ = true;
      ctx->fireTransportInactive();
    }
  }

void wangle::AsyncSocketHandler::getReadBuffer ( void **  bufReturn, size_t *  lenReturn  )

inlineoverridevirtual

When data becomes available, getReadBuffer() will be invoked to get the buffer into which data should be read.

This method allows the ReadCallback to delay buffer allocation until data becomes available. This allows applications to manage large numbers of idle connections, without having to maintain a separate read buffer for each idle connection.

It is possible that in some cases, getReadBuffer() may be called multiple times before readDataAvailable() is invoked. In this case, the data will be written to the buffer returned from the most recent call to readDataAvailable(). If the previous calls to readDataAvailable() returned different buffers, the ReadCallback is responsible for ensuring that they are not leaked.

If getReadBuffer() throws an exception, returns a nullptr buffer, or returns a 0 length, the ReadCallback will be uninstalled and its readError() method will be invoked.

getReadBuffer() is not allowed to change the transport state before it returns. (For example, it should never uninstall the read callback, or set a different read callback.)

Parameters

bufReturn	getReadBuffer() should update *bufReturn to contain the address of the read buffer. This parameter will never be nullptr.
lenReturn	getReadBuffer() should update *lenReturn to contain the maximum number of bytes that may be written to the read buffer. This parameter will never be nullptr.

Implements folly::AsyncReader::ReadCallback.

Definition at line 142 of file AsyncSocketHandler.h.

References bufQueue_, wangle::HandlerBase< HandlerContext< R, W > >::getContext(), wangle::HandlerContext< In, Out >::getReadBufferSettings(), and folly::IOBufQueue::preallocate().

                                                                   {
    const auto readBufferSettings = getContext()->getReadBufferSettings();
    const auto ret = bufQueue_.preallocate(
        readBufferSettings.first,
        readBufferSettings.second);
    *bufReturn = ret.first;
    *lenReturn = ret.second;
  }

void wangle::AsyncSocketHandler::readDataAvailable ( size_t  len )

inlineoverridevirtualnoexcept

readDataAvailable() will be invoked when data has been successfully read into the buffer returned by the last call to getReadBuffer().

The read callback remains installed after readDataAvailable() returns. It must be explicitly uninstalled to stop receiving read events. getReadBuffer() will be called at least once before each call to readDataAvailable(). getReadBuffer() will also be called before any call to readEOF().

Parameters

len	The number of bytes placed in the buffer.

Implements folly::AsyncReader::ReadCallback.

Definition at line 151 of file AsyncSocketHandler.h.

References bufQueue_, wangle::HandlerContext< In, Out >::fireRead(), wangle::HandlerBase< HandlerContext< R, W > >::getContext(), folly::IOBufQueue::postallocate(), and refreshTimeout().

                                                       {
    refreshTimeout();
    bufQueue_.postallocate(len);
    getContext()->fireRead(bufQueue_);
  }

void wangle::AsyncSocketHandler::readEOF ( Context *  ctx )

inlineoverride

Definition at line 138 of file AsyncSocketHandler.h.

                                      {
    ctx->fireReadEOF();
  }

void wangle::AsyncSocketHandler::readEOF ( )

inlineoverridevirtualnoexcept

readEOF() will be invoked when the transport is closed.

The read callback will be automatically uninstalled immediately before readEOF() is invoked.

Implements folly::AsyncReader::ReadCallback.

Definition at line 157 of file AsyncSocketHandler.h.

References wangle::HandlerContext< In, Out >::fireReadEOF(), and wangle::HandlerBase< HandlerContext< R, W > >::getContext().

                                   {
    getContext()->fireReadEOF();
  }

void wangle::AsyncSocketHandler::readErr ( const folly::AsyncSocketException &  ex )

inlineoverridevirtualnoexcept

readError() will be invoked if an error occurs reading from the transport.

The read callback will be automatically uninstalled immediately before readError() is invoked.

Parameters

ex	An exception describing the error that occurred.

Implements folly::AsyncReader::ReadCallback.

Definition at line 161 of file AsyncSocketHandler.h.

References wangle::HandlerContext< In, Out >::fireReadException(), and wangle::HandlerBase< HandlerContext< R, W > >::getContext().

                      {
    getContext()->fireReadException(
        folly::make_exception_wrapper<folly::AsyncSocketException>(ex));
  }

void wangle::AsyncSocketHandler::refreshTimeout ( )

inlineprivate

Definition at line 168 of file AsyncSocketHandler.h.

References wangle::HandlerBase< HandlerContext< R, W > >::getContext(), wangle::HandlerContext< In, Out >::getPipeline(), wangle::PipelineBase::getPipelineManager(), and wangle::PipelineManager::refreshTimeout().

Referenced by readDataAvailable(), and write().

                        {
    auto manager = getContext()->getPipeline()->getPipelineManager();
    if (manager) {
      manager->refreshTimeout();
    }
  }

folly::Future<folly::Unit> wangle::AsyncSocketHandler::shutdown ( Context *  ctx, bool  closeWithReset  )

inlineprivate

Definition at line 175 of file AsyncSocketHandler.h.

References detachReadCallback(), folly::makeFuture(), pipelineDeleted_, and socket_.

Referenced by close(), and writeException().

                                                                     {
    if (socket_) {
      detachReadCallback();
      if (closeWithReset) {
        socket_->closeWithReset();
      } else {
        socket_->closeNow();
      }
    }
    if (!pipelineDeleted_) {
      pipelineDeleted_ = true;
      ctx->getPipeline()->deletePipeline();
    }
    return folly::makeFuture();
  }

void wangle::AsyncSocketHandler::transportActive ( Context *  ctx )

inlineoverride

Definition at line 81 of file AsyncSocketHandler.h.

References attachReadCallback(), firedInactive_, and socket_.

                                              {
    ctx->getPipeline()->setTransport(socket_);
    attachReadCallback();
    firedInactive_ = false;
    ctx->fireTransportActive();
  }

void wangle::AsyncSocketHandler::transportInactive ( Context *  ctx )

inlineoverride

Definition at line 88 of file AsyncSocketHandler.h.

References detachReadCallback().

                                                {
    // detachReadCallback invokes fireTransportInactive() if the transport
    // is currently active.
    detachReadCallback();
    ctx->getPipeline()->setTransport(nullptr);
  }

folly::Future<folly::Unit> wangle::AsyncSocketHandler::write ( Context *  ctx, std::unique_ptr< folly::IOBuf >  buf  )

inlineoverride

Definition at line 99 of file AsyncSocketHandler.h.

References folly::makeFuture(), folly::gen::move, refreshTimeout(), socket_, and UNLIKELY.

                                              {
    refreshTimeout();
    if (UNLIKELY(!buf)) {
      return folly::makeFuture();
    }

    if (!socket_->good()) {
      VLOG(5) << "socket is closed in write()";
      return folly::makeFuture<folly::Unit>(folly::AsyncSocketException(
          folly::AsyncSocketException::AsyncSocketExceptionType::NOT_OPEN,
          "socket is closed in write()"));
    }

    auto cb = new WriteCallback();
    auto future = cb->promise_.getFuture();
    socket_->writeChain(cb, std::move(buf), ctx->getWriteFlags());
    return future;
  }

folly::Future<folly::Unit> wangle::AsyncSocketHandler::writeException ( Context *  ctx, folly::exception_wrapper    )

inlineoverride

Definition at line 120 of file AsyncSocketHandler.h.

References shutdown().

                                                                             {
    return shutdown(ctx, true);
  }

Member Data Documentation

folly::IOBufQueue wangle::AsyncSocketHandler::bufQueue_ {folly::IOBufQueue::cacheChainLength()}

private

Definition at line 209 of file AsyncSocketHandler.h.

Referenced by getReadBuffer(), and readDataAvailable().

bool wangle::AsyncSocketHandler::firedInactive_ {false}

private

Definition at line 211 of file AsyncSocketHandler.h.

Referenced by detachReadCallback(), and transportActive().

bool wangle::AsyncSocketHandler::pipelineDeleted_ {false}

private

Definition at line 212 of file AsyncSocketHandler.h.

Referenced by shutdown().

std::shared_ptr<folly::AsyncTransportWrapper> wangle::AsyncSocketHandler::socket_ {nullptr}

private

Definition at line 210 of file AsyncSocketHandler.h.

Referenced by attachEventBase(), attachReadCallback(), close(), detachEventBase(), detachReadCallback(), shutdown(), transportActive(), write(), and ~AsyncSocketHandler().

---

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

• proxygen/wangle/wangle/channel/AsyncSocketHandler.h