folly::AsyncPipeReader Class Reference

#include <AsyncPipe.h>

Inheritance diagram for folly::AsyncPipeReader:

Public Types
typedef std::unique_ptr< AsyncPipeReader, folly::DelayedDestruction::Destructor >	UniquePtr
Public Types inherited from folly::EventHandler
enum	EventFlags {   NONE = 0, READ = EV_READ, WRITE = EV_WRITE, READ_WRITE = (READ | WRITE),   PERSIST = EV_PERSIST }

Public Member Functions
	AsyncPipeReader (folly::EventBase *eventBase, int pipeFd)
void	setReadCB (AsyncReader::ReadCallback *callback) override
AsyncReader::ReadCallback *	getReadCallback () const override
void	setCloseCallback (std::function< void(int)> closeCb)
Public Member Functions inherited from folly::EventHandler
	EventHandler (EventBase *eventBase, int fd)
	EventHandler (EventBase *eventBase=nullptr, NetworkSocket fd=NetworkSocket())
virtual	~EventHandler ()
bool	registerHandler (uint16_t events)
void	unregisterHandler ()
bool	isHandlerRegistered () const
void	attachEventBase (EventBase *eventBase)
void	detachEventBase ()
void	changeHandlerFD (int fd)
void	changeHandlerFD (NetworkSocket fd)
void	initHandler (EventBase *eventBase, int fd)
void	initHandler (EventBase *eventBase, NetworkSocket fd)
uint16_t	getRegisteredEvents () const
bool	registerInternalHandler (uint16_t events)
bool	isPending () const
Public Member Functions inherited from folly::DelayedDestruction
virtual void	destroy ()
bool	getDestroyPending () const
Public Member Functions inherited from folly::DelayedDestructionBase
virtual	~DelayedDestructionBase ()=default

Static Public Member Functions
template<typename... Args>
static UniquePtr	newReader (Args &&...args)

Private Member Functions
	~AsyncPipeReader () override
void	handlerReady (uint16_t events) noexceptoverride
void	failRead (const AsyncSocketException &ex)
void	close ()

Private Attributes
int	fd_
AsyncReader::ReadCallback *	readCallback_ {nullptr}
std::function< void(int)>	closeCb_

Additional Inherited Members
Protected Member Functions inherited from folly::AsyncReader
virtual	~AsyncReader ()=default
Protected Member Functions inherited from folly::DelayedDestruction
	~DelayedDestruction () override=default
	DelayedDestruction ()
Protected Member Functions inherited from folly::DelayedDestructionBase
	DelayedDestructionBase ()
uint32_t	getDestructorGuardCount () const

Detailed Description

Read from a pipe in an async manner.

Definition at line 34 of file AsyncPipe.h.

Member Typedef Documentation

typedef std:: unique_ptr<AsyncPipeReader, folly::DelayedDestruction::Destructor> folly::AsyncPipeReader::UniquePtr

Definition at line 40 of file AsyncPipe.h.

Constructor & Destructor Documentation

folly::AsyncPipeReader::AsyncPipeReader ( folly::EventBase *  eventBase, int  pipeFd  )

inline

Definition at line 47 of file AsyncPipe.h.

Referenced by newReader().

      : EventHandler(eventBase, pipeFd), fd_(pipeFd) {}

folly::AsyncPipeReader::~AsyncPipeReader ( )

overrideprivate

Definition at line 28 of file AsyncPipe.cpp.

References close().

Referenced by setCloseCallback().

                                  {
  close();
}

Member Function Documentation

void folly::AsyncPipeReader::close ( )

private

Definition at line 43 of file AsyncPipe.cpp.

References folly::EventHandler::changeHandlerFD(), closeCb_, fd_, and folly::EventHandler::unregisterHandler().

Referenced by folly::AsyncPipeWriter::closeNow(), failRead(), setCloseCallback(), and ~AsyncPipeReader().

                            {
  unregisterHandler();
  if (fd_ >= 0) {
    changeHandlerFD(-1);

    if (closeCb_) {
      closeCb_(fd_);
    } else {
      ::close(fd_);
    }
    fd_ = -1;
  }
}

void folly::AsyncPipeReader::failRead ( const AsyncSocketException &  ex )

private

Definition at line 32 of file AsyncPipe.cpp.

References close(), fd_, readCallback_, and folly::AsyncReader::ReadCallback::readErr().

Referenced by handlerReady(), and setCloseCallback().

                                                             {
  VLOG(5) << "AsyncPipeReader(this=" << this << ", fd=" << fd_
          << "): failed while reading: " << ex.what();

  DCHECK(readCallback_ != nullptr);
  AsyncReader::ReadCallback* callback = readCallback_;
  readCallback_ = nullptr;
  callback->readErr(ex);
  close();
}

AsyncReader::ReadCallback* folly::AsyncPipeReader::getReadCallback ( ) const

inlineoverridevirtual

Get the read callback

Implements folly::AsyncReader.

Definition at line 69 of file AsyncPipe.h.

References readCallback_.

                                                            {
    return readCallback_;
  }

void folly::AsyncPipeReader::handlerReady ( uint16_t  events )

overrideprivatevirtualnoexcept

handlerReady() is invoked when the handler is ready.

Parameters

events

A bitset indicating the events that are ready.

Implements folly::EventHandler.

Definition at line 57 of file AsyncPipe.cpp.

References folly::IOBuf::append(), folly::AsyncSocketException::BAD_ARGS, folly::IOBuf::capacity(), folly::IOBuf::create(), failRead(), fd_, folly::AsyncReader::ReadCallback::getReadBuffer(), folly::AsyncSocketException::INVALID_STATE, folly::AsyncReader::ReadCallback::isBufferMovable(), folly::AsyncReader::ReadCallback::maxBufferSize(), folly::gen::move, folly::EventHandler::READ, folly::AsyncReader::ReadCallback::readBufferAvailable(), readCallback_, folly::AsyncReader::ReadCallback::readDataAvailable(), folly::AsyncReader::ReadCallback::readEOF(), folly::readNoInt(), folly::EventHandler::unregisterHandler(), and folly::IOBuf::writableBuffer().

Referenced by setCloseCallback(), and folly::AsyncPipeWriter::writev().

                                                           {
  DestructorGuard dg(this);
  CHECK(events & EventHandler::READ);

  VLOG(5) << "AsyncPipeReader::handlerReady() this=" << this << ", fd=" << fd_;
  assert(readCallback_ != nullptr);

  while (readCallback_) {
    // - What API does callback support?
    const auto movable = readCallback_->isBufferMovable(); // noexcept

    // Get the buffer to read into.
    void* buf = nullptr;
    size_t buflen = 0;
    std::unique_ptr<IOBuf> ioBuf;

    if (movable) {
      ioBuf = IOBuf::create(readCallback_->maxBufferSize());
      buf = ioBuf->writableBuffer();
      buflen = ioBuf->capacity();
    } else {
      try {
        readCallback_->getReadBuffer(&buf, &buflen);
      } catch (const std::exception& ex) {
        AsyncSocketException aex(
            AsyncSocketException::BAD_ARGS,
            string("ReadCallback::getReadBuffer() "
                   "threw exception: ") +
                ex.what());
        failRead(aex);
        return;
      } catch (...) {
        AsyncSocketException aex(
            AsyncSocketException::BAD_ARGS,
            string("ReadCallback::getReadBuffer() "
                   "threw non-exception type"));
        failRead(aex);
        return;
      }
      if (buf == nullptr || buflen == 0) {
        AsyncSocketException aex(
            AsyncSocketException::INVALID_STATE,
            string("ReadCallback::getReadBuffer() "
                   "returned empty buffer"));
        failRead(aex);
        return;
      }
    }

    // Perform the read
    ssize_t bytesRead = folly::readNoInt(fd_, buf, buflen);

    if (bytesRead > 0) {
      if (movable) {
        ioBuf->append(std::size_t(bytesRead));
        readCallback_->readBufferAvailable(std::move(ioBuf));
      } else {
        readCallback_->readDataAvailable(size_t(bytesRead));
      }
      // Fall through and continue around the loop if the read
      // completely filled the available buffer.
      // Note that readCallback_ may have been uninstalled or changed inside
      // readDataAvailable().
      if (static_cast<size_t>(bytesRead) < buflen) {
        return;
      }
    } else if (bytesRead < 0 && (errno == EAGAIN || errno == EWOULDBLOCK)) {
      // No more data to read right now.
      return;
    } else if (bytesRead < 0) {
      AsyncSocketException ex(
          AsyncSocketException::INVALID_STATE, "read failed", errno);
      failRead(ex);
      return;
    } else {
      assert(bytesRead == 0);
      // EOF

      unregisterHandler();
      AsyncReader::ReadCallback* callback = readCallback_;
      readCallback_ = nullptr;
      callback->readEOF();
      return;
    }
    // Max reads per loop?
  }
}

template<typename... Args>

static UniquePtr folly::AsyncPipeReader::newReader ( Args &&...  args )

inlinestatic

Definition at line 43 of file AsyncPipe.h.

References AsyncPipeReader().

Referenced by folly::AsyncSSLSocket::willBlock().

                                             {
    return UniquePtr(new AsyncPipeReader(std::forward<Args>(args)...));
  }

void folly::AsyncPipeReader::setCloseCallback ( std::function< void(int)>  closeCb )

inline

Set a special hook to close the socket (otherwise, will call close())

Definition at line 76 of file AsyncPipe.h.

References close(), closeCb_, failRead(), handlerReady(), folly::pushmi::__adl::noexcept(), uint16_t, and ~AsyncPipeReader().

                                                        {
    closeCb_ = closeCb;
  }

void folly::AsyncPipeReader::setReadCB ( AsyncReader::ReadCallback *  callback )

inlineoverridevirtual

Set the read callback and automatically install/uninstall the handler for events.

Implements folly::AsyncReader.

Definition at line 54 of file AsyncPipe.h.

References folly::EventHandler::isHandlerRegistered(), folly::EventHandler::PERSIST, folly::EventHandler::READ, readCallback_, folly::EventHandler::registerHandler(), and folly::EventHandler::unregisterHandler().

                                                             {
    if (callback == readCallback_) {
      return;
    }
    readCallback_ = callback;
    if (readCallback_ && !isHandlerRegistered()) {
      registerHandler(EventHandler::READ | EventHandler::PERSIST);
    } else if (!readCallback_ && isHandlerRegistered()) {
      unregisterHandler();
    }
  }

Member Data Documentation

std::function<void(int)> folly::AsyncPipeReader::closeCb_

private

Definition at line 89 of file AsyncPipe.h.

Referenced by close(), folly::AsyncPipeWriter::closeNow(), setCloseCallback(), and folly::AsyncPipeWriter::setCloseCallback().

int folly::AsyncPipeReader::fd_

private

Definition at line 87 of file AsyncPipe.h.

Referenced by close(), folly::AsyncPipeWriter::closed(), folly::AsyncPipeWriter::closeNow(), failRead(), handlerReady(), and folly::AsyncPipeWriter::handleWrite().

AsyncReader::ReadCallback* folly::AsyncPipeReader::readCallback_ {nullptr}

private

Definition at line 88 of file AsyncPipe.h.

Referenced by failRead(), getReadCallback(), handlerReady(), and setReadCB().

---

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

• proxygen/folly/folly/io/async/AsyncPipe.h
• proxygen/folly/folly/io/async/AsyncPipe.cpp