proxygen: folly::AsyncPipeWriter Class Reference

#include <AsyncPipe.h>

Inheritance diagram for folly::AsyncPipeWriter:

Public Types
typedef std::unique_ptr< AsyncPipeWriter, 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
	AsyncPipeWriter (folly::EventBase *eventBase, int pipeFd)

void	write (std::unique_ptr< folly::IOBuf > iob, AsyncWriter::WriteCallback *wcb=nullptr)

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

bool	closed () const

void	closeOnEmpty ()

void	closeNow ()

bool	hasPendingWrites () const

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

void	writev (folly::AsyncWriter::WriteCallback , const iovec , size_t, WriteFlags=WriteFlags::NONE) override

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

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	newWriter (Args &&...args)

Private Member Functions
void	handlerReady (uint16_t events) noexceptoverride

void	handleWrite ()

void	failAllWrites (const AsyncSocketException &ex)

	~AsyncPipeWriter () override

Private Attributes
int	fd_

std::list< std::pair< folly::IOBufQueue, AsyncWriter::WriteCallback * > >	queue_

bool	closeOnEmpty_ {false}

std::function< void(int)>	closeCb_

Additional Inherited Members
Protected Member Functions inherited from folly::AsyncWriter
virtual	~AsyncWriter ()=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

Write to a pipe in an async manner.

Definition at line 95 of file AsyncPipe.h.

Member Typedef Documentation

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

Definition at line 101 of file AsyncPipe.h.

Constructor & Destructor Documentation

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

inline

Definition at line 108 of file AsyncPipe.h.

References fizz::detail::write().

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

folly::EventHandler::EventHandler

EventHandler(EventBase *eventBase, int fd)

Definition: EventHandler.h:65

folly::AsyncPipeWriter::fd_

int fd_

Definition: AsyncPipe.h:176

folly::AsyncPipeWriter::~AsyncPipeWriter ( )

inlineoverrideprivate

Definition at line 181 of file AsyncPipe.h.

                               {
     closeNow();
   }

Member Function Documentation

bool folly::AsyncPipeWriter::closed ( ) const

inline

Returns true if the pipe is closed

Definition at line 129 of file AsyncPipe.h.

References folly::AsyncPipeReader::fd_.

                       {
     return (fd_ < 0 || closeOnEmpty_);
   }

void folly::AsyncPipeWriter::closeNow ( )

Close the pipe immediately, and fail all pending writes

Definition at line 187 of file AsyncPipe.cpp.

References folly::EventHandler::changeHandlerFD(), folly::AsyncPipeReader::close(), folly::AsyncPipeReader::closeCb_, folly::AsyncPipeReader::fd_, folly::AsyncSocketException::NOT_OPEN, and folly::EventHandler::unregisterHandler().

                                {
   VLOG(5) << "close now";
   if (!queue_.empty()) {
     failAllWrites(AsyncSocketException(
         AsyncSocketException::NOT_OPEN, "closed with pending writes"));
   }
   if (fd_ >= 0) {
     unregisterHandler();
     changeHandlerFD(-1);
     if (closeCb_) {
       closeCb_(fd_);
     } else {
       close(fd_);
     }
     fd_ = -1;
   }
 }

void folly::AsyncPipeWriter::closeOnEmpty ( )

Notify the pipe to close as soon as all pending writes complete

Definition at line 177 of file AsyncPipe.cpp.

References folly::EventHandler::isHandlerRegistered().

                                    {
   VLOG(5) << "close on empty";
   if (queue_.empty()) {
     closeNow();
   } else {
     closeOnEmpty_ = true;
     CHECK(isHandlerRegistered());
   }
 }

void folly::AsyncPipeWriter::failAllWrites ( const AsyncSocketException & ex )

private

Definition at line 205 of file AsyncPipe.cpp.

                                                                   {
   DestructorGuard dg(this);
   while (!queue_.empty()) {
     // the first entry of the queue could have had a partial write, but needs to
     // be tracked.
     if (queue_.front().second) {
       queue_.front().second->writeErr(0, ex);
     }
     queue_.pop_front();
   }
 }

void folly::AsyncPipeWriter::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 217 of file AsyncPipe.cpp.

References folly::EventHandler::WRITE.

                                                            {
   CHECK(events & EventHandler::WRITE);
 
   handleWrite();
 }

void folly::AsyncPipeWriter::handleWrite ( )

private

Definition at line 223 of file AsyncPipe.cpp.

References folly::IOBufQueue::empty(), folly::AsyncPipeReader::fd_, folly::IOBufQueue::front(), folly::AsyncSocketException::INTERNAL_ERROR, folly::EventHandler::registerHandler(), folly::IOBufQueue::trimStart(), folly::EventHandler::unregisterHandler(), folly::EventHandler::WRITE, and folly::writeNoInt().

                                   {
   DestructorGuard dg(this);
   assert(!queue_.empty());
   do {
     auto& front = queue_.front();
     folly::IOBufQueue& curQueue = front.first;
     DCHECK(!curQueue.empty());
     // someday, support writev.  The logic for partial writes is a bit complex
     const IOBuf* head = curQueue.front();
     CHECK(head->length());
     ssize_t rc = folly::writeNoInt(fd_, head->data(), head->length());
     if (rc < 0) {
       if (errno == EAGAIN || errno == EWOULDBLOCK) {
         // pipe is full
         VLOG(5) << "write blocked";
         registerHandler(EventHandler::WRITE);
         return;
       } else {
         failAllWrites(AsyncSocketException(
             AsyncSocketException::INTERNAL_ERROR, "write failed", errno));
         closeNow();
         return;
       }
     } else if (rc == 0) {
       registerHandler(EventHandler::WRITE);
       return;
     }
     curQueue.trimStart(size_t(rc));
     if (curQueue.empty()) {
       auto cb = front.second;
       queue_.pop_front();
       if (cb) {
         cb->writeSuccess();
       }
     } else {
       VLOG(5) << "partial write blocked";
     }
   } while (!queue_.empty());
 
   if (closeOnEmpty_) {
     closeNow();
   } else {
     unregisterHandler();
   }
 }

bool folly::AsyncPipeWriter::hasPendingWrites ( ) const

inline

Return true if there are currently writes pending (eg: the pipe is blocked for writing)

Definition at line 147 of file AsyncPipe.h.

                                 {
     return !queue_.empty();
   }

template<typename... Args>

static UniquePtr folly::AsyncPipeWriter::newWriter ( Args &&... args )

inlinestatic

Definition at line 104 of file AsyncPipe.h.

Referenced by folly::TEST().

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

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

inline

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

Definition at line 122 of file AsyncPipe.h.

References folly::AsyncPipeReader::closeCb_.

                                                         {
     closeCb_ = closeCb;
   }

void folly::AsyncPipeWriter::write	(	std::unique_ptr< folly::IOBuf >	iob,
		AsyncWriter::WriteCallback *	wcb = `nullptr`
	)

Asynchronously write the given iobuf to this pipe, and invoke the callback on success/error.

Definition at line 145 of file AsyncPipe.cpp.

References folly::IOBufQueue::append(), folly::EventHandler::isHandlerRegistered(), folly::gen::move, folly::AsyncSocketException::NOT_OPEN, and folly::AsyncWriter::WriteCallback::writeErr().

                                         {
   if (closed()) {
     if (callback) {
       AsyncSocketException ex(
           AsyncSocketException::NOT_OPEN, "attempt to write to closed pipe");
       callback->writeErr(0, ex);
     }
     return;
   }
   bool wasEmpty = (queue_.empty());
   folly::IOBufQueue iobq;
   iobq.append(std::move(buf));
   std::pair<folly::IOBufQueue, AsyncWriter::WriteCallback*> p(
       std::move(iobq), callback);
   queue_.emplace_back(std::move(p));
   if (wasEmpty) {
     handleWrite();
   } else {
     CHECK(!queue_.empty());
     CHECK(isHandlerRegistered());
   }
 }

void folly::AsyncPipeWriter::write	(	folly::AsyncWriter::WriteCallback *	callback,
		const void *	buf,
		size_t	bytes,
		WriteFlags	flags = `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::AsyncWriter.

Definition at line 152 of file AsyncPipe.h.

References folly::IOBuf::wrapBuffer().

                                                   {
     writeChain(callback, IOBuf::wrapBuffer(buf, bytes), flags);
   }

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

overridevirtual

Implements folly::AsyncWriter.

Definition at line 170 of file AsyncPipe.cpp.

References folly::gen::move, and fizz::detail::write().

                 {
   write(std::move(buf), callback);
 }

void folly::AsyncPipeWriter::writev	(	folly::AsyncWriter::WriteCallback *	callback,
		const iovec *	vec,
		size_t	count,
		WriteFlags	flags = `WriteFlags::NONE`
	)

inlineoverridevirtual

Implements folly::AsyncWriter.

Definition at line 159 of file AsyncPipe.h.

References folly::AsyncPipeReader::handlerReady(), folly::pushmi::__adl::noexcept(), folly::NONE, and uint16_t.

                                             {
     throw std::runtime_error("writev is not supported. Please use writeChain.");
   }

Member Data Documentation

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

private

Definition at line 179 of file AsyncPipe.h.

bool folly::AsyncPipeWriter::closeOnEmpty_ {false}

private

Definition at line 178 of file AsyncPipe.h.

int folly::AsyncPipeWriter::fd_

private

Definition at line 176 of file AsyncPipe.h.

std::list<std::pair<folly::IOBufQueue, AsyncWriter::WriteCallback*> > folly::AsyncPipeWriter::queue_

private

Definition at line 177 of file AsyncPipe.h.

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

Public Types

Public Member Functions

Static Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation