proxygen: TestAsyncTransport Class Reference

#include <TestAsyncTransport.h>

Inheritance diagram for TestAsyncTransport:

Classes
class	ReadEvent

class	WriteEvent

Public Member Functions
	TestAsyncTransport (folly::EventBase *eventBase)

void	setReadCB (AsyncTransportWrapper::ReadCallback *callback) override

ReadCallback *	getReadCallback () const override

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

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

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

void	close () override

void	closeNow () override

void	shutdownWrite () override

void	shutdownWriteNow () override

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

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

bool	good () const override

bool	readable () const override

bool	connecting () const override

bool	error () const override

void	attachEventBase (folly::EventBase *eventBase) override

void	detachEventBase () override

bool	isDetachable () const override

folly::EventBase *	getEventBase () const override

void	setSendTimeout (uint32_t milliseconds) override

uint32_t	getSendTimeout () const override

void	addReadEvent (const void *buf, size_t buflen, std::chrono::milliseconds delayFromPrevious)

void	addReadEvent (folly::IOBufQueue &chain, std::chrono::milliseconds delayFromPrevious)

void	addReadEvent (const char *buf, std::chrono::milliseconds delayFromPrevious=std::chrono::milliseconds(0))

void	addReadEOF (std::chrono::milliseconds delayFromPrevious)

void	addReadError (const folly::AsyncSocketException &ex, std::chrono::milliseconds delayFromPrevious)

void	startReadEvents ()

void	pauseWrites ()

void	resumeWrites ()

std::deque< std::shared_ptr< WriteEvent > > *	getWriteEvents ()

uint32_t	getEORCount ()

uint32_t	getCorkCount ()

size_t	getAppBytesWritten () const override

size_t	getRawBytesWritten () const override

size_t	getAppBytesReceived () const override

size_t	getRawBytesReceived () const override

bool	isEorTrackingEnabled () const override

void	setEorTracking (bool) override

Public Member Functions inherited from folly::AsyncTransportWrapper
void	setReadCB (ReadCallback *callback) override=0

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

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

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

virtual const AsyncTransportWrapper *	getWrappedTransport () const

template<class T >
const T *	getUnderlyingTransport () const

template<class T >
T *	getUnderlyingTransport ()

Public Member Functions inherited from folly::AsyncTransport
virtual void	closeWithReset ()

virtual bool	writable () const

virtual bool	isPending () const

SocketAddress	getLocalAddress () const

void	getAddress (SocketAddress *address) const override

SocketAddress	getPeerAddress () const

virtual ssl::X509UniquePtr	getPeerCert () const

virtual const X509 *	getSelfCert () const

virtual const AsyncTransportCertificate *	getPeerCertificate () const

virtual const AsyncTransportCertificate *	getSelfCertificate () const

virtual std::string	getApplicationProtocol () const noexcept

virtual std::string	getSecurityProtocol () const

virtual bool	isReplaySafe () const

virtual void	setReplaySafetyCallback (ReplaySafetyCallback *callback)

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

Private Types
enum	StateEnum { kStateOpen, kStatePaused, kStateClosed, kStateError }

Private Types inherited from folly::AsyncTimeout
typedef TimeoutManager::InternalEnum	InternalEnum

Private Member Functions
bool	writesAllowed () const

	TestAsyncTransport (TestAsyncTransport const &)

TestAsyncTransport &	operator= (TestAsyncTransport const &)

void	addReadEvent (const std::shared_ptr< ReadEvent > &event)

void	scheduleNextReadEvent (proxygen::TimePoint now)

void	fireNextReadEvent ()

void	fireOneReadEvent ()

void	failPendingWrites ()

void	timeoutExpired () noexceptoverride

Private Member Functions inherited from folly::AsyncTimeout
	AsyncTimeout (TimeoutManager *timeoutManager)

	AsyncTimeout (EventBase *eventBase)

	AsyncTimeout (TimeoutManager *timeoutManager, InternalEnum internal)

	AsyncTimeout (EventBase *eventBase, InternalEnum internal)

	AsyncTimeout ()

virtual	~AsyncTimeout ()

bool	scheduleTimeout (uint32_t milliseconds)

bool	scheduleTimeout (TimeoutManager::timeout_type timeout)

void	cancelTimeout ()

bool	isScheduled () const

void	attachTimeoutManager (TimeoutManager *timeoutManager, InternalEnum internal=InternalEnum::NORMAL)

void	attachEventBase (EventBase *eventBase, InternalEnum internal=InternalEnum::NORMAL)

void	detachTimeoutManager ()

void	detachEventBase ()

const TimeoutManager *	getTimeoutManager ()

struct event *	getEvent ()

Private Attributes
folly::EventBase *	eventBase_

folly::AsyncTransportWrapper::ReadCallback *	readCallback_

uint32_t	sendTimeout_

proxygen::TimePoint	prevReadEventTime_ {}

proxygen::TimePoint	nextReadEventTime_ {}

StateEnum	readState_

StateEnum	writeState_

std::deque< std::shared_ptr< ReadEvent > >	readEvents_

std::deque< std::shared_ptr< WriteEvent > >	writeEvents_

std::deque< std::pair< std::shared_ptr< WriteEvent >, AsyncTransportWrapper::WriteCallback * > >	pendingWriteEvents_

uint32_t	eorCount_ {0}

uint32_t	corkCount_ {0}

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

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

Static Private Member Functions inherited from folly::AsyncTimeout
template<typename TCallback >
static std::unique_ptr< AsyncTimeout >	make (TimeoutManager &manager, TCallback &&callback)

template<typename TCallback >
static std::unique_ptr< AsyncTimeout >	schedule (TimeoutManager::timeout_type timeout, TimeoutManager &manager, TCallback &&callback)

Detailed Description

Definition at line 19 of file TestAsyncTransport.h.

Member Enumeration Documentation

enum TestAsyncTransport::StateEnum

private

Enumerator
kStateOpen
kStatePaused
kStateClosed
kStateError

Definition at line 121 of file TestAsyncTransport.h.

                  {
     kStateOpen,
     kStatePaused,
     kStateClosed,
     kStateError,
   };

Constructor & Destructor Documentation

TestAsyncTransport::TestAsyncTransport ( folly::EventBase * eventBase )

explicit

Definition at line 168 of file TestAsyncTransport.cpp.

Referenced by writesAllowed().

   : AsyncTimeout(eventBase),
     eventBase_(eventBase),
     readCallback_(nullptr),
     sendTimeout_(0),
     readState_(kStateOpen),
     writeState_(kStateOpen),
     readEvents_()
 {
 }

TestAsyncTransport::TestAsyncTransport ( TestAsyncTransport const & )

private

Member Function Documentation

void TestAsyncTransport::addReadEOF ( std::chrono::milliseconds delayFromPrevious )

Definition at line 455 of file TestAsyncTransport.cpp.

References addReadEvent().

                                                                       {
   addReadEvent(nullptr, 0, delayFromPrevious);
 }

void TestAsyncTransport::addReadError	(	const folly::AsyncSocketException &	ex,
		std::chrono::milliseconds	delayFromPrevious
	)

Definition at line 460 of file TestAsyncTransport.cpp.

References addReadEvent(), and readEvents_.

                                                                           {
   if (!readEvents_.empty() && readEvents_.back()->isFinalEvent()) {
     LOG(FATAL) << "cannot add a read error after an error or EOF";
   }
 
   auto event = std::make_shared<ReadEvent>(ex, delayFromPrevious);
   addReadEvent(event);
 }

void TestAsyncTransport::addReadEvent	(	const void *	buf,
		size_t	buflen,
		std::chrono::milliseconds	delayFromPrevious
	)

Definition at line 438 of file TestAsyncTransport.cpp.

References readEvents_.

Referenced by addReadEOF(), addReadError(), addReadEvent(), and writesAllowed().

                                                                           {
   if (!readEvents_.empty() && readEvents_.back()->isFinalEvent()) {
     LOG(FATAL) << "cannot add more read events after an error or EOF";
   }
 
   auto event = std::make_shared<ReadEvent>(buf, buflen, delayFromPrevious);
   addReadEvent(event);
 }

void TestAsyncTransport::addReadEvent	(	folly::IOBufQueue &	chain,
		std::chrono::milliseconds	delayFromPrevious
	)

Definition at line 426 of file TestAsyncTransport.cpp.

References addReadEvent(), folly::IOBuf::data(), folly::IOBuf::length(), and folly::IOBufQueue::pop_front().

                                                                           {
   while (true) {
     unique_ptr<IOBuf> cur = chain.pop_front();
     if (!cur) {
       break;
     }
     addReadEvent(cur->data(), cur->length(), delayFromPrevious);
   }
 }

void TestAsyncTransport::addReadEvent	(	const char *	buf,
		std::chrono::milliseconds	delayFromPrevious = `std::chrono::milliseconds(0)`
	)

Definition at line 449 of file TestAsyncTransport.cpp.

References addReadEvent().

                                                                           {
   addReadEvent(buf, strlen(buf), delayFromPrevious);
 }

void TestAsyncTransport::addReadEvent ( const std::shared_ptr< ReadEvent > & event )

private

Definition at line 471 of file TestAsyncTransport.cpp.

References proxygen::getCurrentTime(), nextReadEventTime_, prevReadEventTime_, readCallback_, readEvents_, scheduleNextReadEvent(), and proxygen::timePointInitialized().

                                                                    {
   bool firstEvent = readEvents_.empty();
   readEvents_.push_back(event);
 
   if (!firstEvent) {
     return;
   }
   if (!proxygen::timePointInitialized(prevReadEventTime_)) {
     return;
   }
 
   nextReadEventTime_ = prevReadEventTime_ + event->getDelay();
   if (readCallback_ == nullptr) {
     return;
   }
 
   scheduleNextReadEvent(proxygen::getCurrentTime());
 }

void TestAsyncTransport::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.

Implements folly::AsyncTransport.

Definition at line 351 of file TestAsyncTransport.cpp.

References eventBase_, and readCallback_.

                                                         {
   CHECK(nullptr == eventBase_);
   CHECK(nullptr == readCallback_);
   eventBase_ = eventBase;
 }

void TestAsyncTransport::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 285 of file TestAsyncTransport.cpp.

References closeNow().

                           {
   closeNow();
 }

void TestAsyncTransport::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 290 of file TestAsyncTransport.cpp.

References kStateClosed, kStateOpen, readCallback_, folly::AsyncReader::ReadCallback::readEOF(), readState_, and shutdownWriteNow().

Referenced by close().

                              {
   if (readState_ == kStateOpen) {
     readState_ = kStateClosed;
 
     if (readCallback_ != nullptr) {
       folly::AsyncTransportWrapper::ReadCallback* callback = readCallback_;
       readCallback_ = nullptr;
       callback->readEOF();
     }
   }
   shutdownWriteNow();
 }

bool TestAsyncTransport::connecting ( ) const

overridevirtual

Determine if transport is connected to the endpoint

Returns: false iff the transport is connected, otherwise true

Implements folly::AsyncTransport.

Definition at line 341 of file TestAsyncTransport.cpp.

                                      {
   return false;
 }

void TestAsyncTransport::detachEventBase ( )

overridevirtual

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 358 of file TestAsyncTransport.cpp.

References eventBase_, and readCallback_.

                                     {
   CHECK_NOTNULL(eventBase_);
   CHECK(nullptr == readCallback_);
   eventBase_ = nullptr;
 }

bool TestAsyncTransport::error ( ) const

overridevirtual

Determine if an error has occurred with this transport.

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

Implements folly::AsyncTransport.

Definition at line 346 of file TestAsyncTransport.cpp.

References kStateError, readState_, and writeState_.

                                 {
   return (readState_ == kStateError || writeState_ == kStateError);
 }

void TestAsyncTransport::failPendingWrites ( )

private

Definition at line 410 of file TestAsyncTransport.cpp.

References g(), pendingWriteEvents_, and folly::AsyncWriter::WriteCallback::writeErr().

Referenced by shutdownWriteNow(), and writesAllowed().

                                       {
   // writeError() callback might try to delete this object
   DestructorGuard g(this);
   while (!pendingWriteEvents_.empty()) {
     auto event = pendingWriteEvents_.front();
     pendingWriteEvents_.pop_front();
     AsyncSocketException ex(AsyncSocketException::NOT_OPEN,
                            "Transport closed locally");
     auto cb = dynamic_cast<WriteCallback*>(event.second);
     if (cb) {
       cb->writeErr(0, ex);
     }
   }
 }

void TestAsyncTransport::fireNextReadEvent ( )

private

Definition at line 518 of file TestAsyncTransport.cpp.

References folly::netops::bind(), eventBase_, fireOneReadEvent(), proxygen::getCurrentTime(), nextReadEventTime_, now(), readCallback_, readEvents_, folly::EventBase::runInLoop(), folly::AsyncTimeout::scheduleTimeout(), and proxygen::timePointInitialized().

Referenced by scheduleNextReadEvent(), timeoutExpired(), and writesAllowed().

                                       {
   DestructorGuard dg(this);
   CHECK(!readEvents_.empty());
   CHECK_NOTNULL(readCallback_);
 
   // maxReadAtOnce prevents us from starving other users of this EventBase
   unsigned int const maxReadAtOnce = 30;
   for (unsigned int n = 0; n < maxReadAtOnce; ++n) {
     fireOneReadEvent();
 
     if (readCallback_ == nullptr || eventBase_ == nullptr ||
         !proxygen::timePointInitialized(nextReadEventTime_)) {
       return;
     }
     auto now = proxygen::getCurrentTime();
     if (nextReadEventTime_ > now) {
       scheduleTimeout(std::chrono::duration_cast<std::chrono::milliseconds>
                       (nextReadEventTime_ - now));
       return;
     }
   }
 
   // Trigger fireNextReadEvent() to be called the next time around the event
   // loop.
   eventBase_->runInLoop(std::bind(&TestAsyncTransport::fireNextReadEvent,
                                        this));
 }

void TestAsyncTransport::fireOneReadEvent ( )

private

Definition at line 547 of file TestAsyncTransport.cpp.

References folly::AsyncReader::ReadCallback::getReadBuffer(), kStateClosed, kStateError, nextReadEventTime_, prevReadEventTime_, readCallback_, folly::AsyncReader::ReadCallback::readDataAvailable(), folly::AsyncReader::ReadCallback::readEOF(), folly::AsyncReader::ReadCallback::readErr(), readEvents_, readState_, and writeState_.

Referenced by fireNextReadEvent(), and writesAllowed().

                                      {
   CHECK(!readEvents_.empty());
   CHECK_NOTNULL(readCallback_);
 
   const shared_ptr<ReadEvent>& event = readEvents_.front();
 
   // Note that we call getReadBuffer() here even if we know the next event may
   // be an EOF or an error.  This matches the behavior of AsyncSocket.
   // (Because AsyncSocket merely gets notification that the socket is readable,
   // and has to call getReadBuffer() before it can make the actual read call to
   // get an error or EOF.)
   void* buf;
   size_t buflen;
   try {
     readCallback_->getReadBuffer(&buf, &buflen);
   } catch (...) {
     // TODO: we should convert the error to a AsyncSocketException and call
     // readError() here.
     LOG(FATAL) << "readCallback_->getReadBuffer() threw an error";
   }
   if (buf == nullptr || buflen == 0) {
     // TODO: we should just call readError() here.
     LOG(FATAL) << "readCallback_->getReadBuffer() returned a nullptr or "
       "empty buffer";
   }
 
   // Handle errors
   if (event->isError()) {
     // Errors immediately move both read and write to an error state
     readState_ = kStateError;
     writeState_ = kStateError;
 
     // event is just a reference to the shared_ptr, so make a real copy of the
     // pointer before popping it off the readEvents_ list.
     shared_ptr<ReadEvent> eventPointerCopy = readEvents_.front();
     readEvents_.pop_front();
     CHECK(readEvents_.empty());
     nextReadEventTime_ = {};
 
     auto callback = readCallback_;
     readCallback_ = nullptr;
     callback->readErr(eventPointerCopy->getException());
     return;
   }
 
   // Handle EOF
   size_t available = event->getLength();
   if (available == 0) {
     readState_ = kStateClosed;
 
     readEvents_.pop_front();
     CHECK(readEvents_.empty());
     nextReadEventTime_ = {};
 
     auto callback = readCallback_;
     readCallback_ = nullptr;
     callback->readEOF();
     return;
   }
 
   // Handle a normal read event
   size_t readlen;
   bool more;
   if (available <= buflen) {
     readlen = available;
     more = false;
   } else {
     readlen = buflen;
     more = true;
   }
   memcpy(buf, event->getBuffer(), readlen);
   if (more) {
     event->consumeData(readlen);
   } else {
     prevReadEventTime_ = nextReadEventTime_;
     // Note: since event is just a reference to the shared_ptr in readEvents_,
     // we shouldn't access the event any more after popping it off here.
     readEvents_.pop_front();
 
     if (readEvents_.empty()) {
       nextReadEventTime_ = {};
     } else {
       nextReadEventTime_ = prevReadEventTime_ + readEvents_.front()->getDelay();
     }
   }
   readCallback_->readDataAvailable(readlen);
 }

size_t TestAsyncTransport::getAppBytesReceived ( ) const

inlineoverridevirtual

Implements folly::AsyncTransport.

Definition at line 115 of file TestAsyncTransport.h.

115 { return 0; }

size_t TestAsyncTransport::getAppBytesWritten ( ) const

inlineoverridevirtual

Implements folly::AsyncTransport.

Definition at line 113 of file TestAsyncTransport.h.

113 { return 0; }

uint32_t TestAsyncTransport::getCorkCount ( )

inline

Definition at line 109 of file TestAsyncTransport.h.

References corkCount_.

                           {
     return corkCount_;
   }

uint32_t TestAsyncTransport::getEORCount ( )

inline

Definition at line 105 of file TestAsyncTransport.h.

References eorCount_.

                          {
     return eorCount_;
   }

EventBase * TestAsyncTransport::getEventBase ( ) const

overridevirtual

Implements folly::AsyncSocketBase.

Definition at line 370 of file TestAsyncTransport.cpp.

References eventBase_.

                                        {
   return eventBase_;
 }

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

overridevirtual

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 325 of file TestAsyncTransport.cpp.

References folly::SocketAddress::setFromIpPort().

                                                              {
   // This isn't really accurate, but close enough for testing.
   addr->setFromIpPort("127.0.0.1", 0);
 }

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

overridevirtual

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 319 of file TestAsyncTransport.cpp.

References folly::SocketAddress::setFromIpPort().

                                                             {
   // This isn't really accurate, but close enough for testing.
   addr->setFromIpPort("127.0.0.1", 0);
 }

size_t TestAsyncTransport::getRawBytesReceived ( ) const

inlineoverridevirtual

Implements folly::AsyncTransport.

Definition at line 116 of file TestAsyncTransport.h.

116 { return 0; }

size_t TestAsyncTransport::getRawBytesWritten ( ) const

inlineoverridevirtual

Implements folly::AsyncTransport.

Definition at line 114 of file TestAsyncTransport.h.

114 { return 0; }

TestAsyncTransport::ReadCallback * TestAsyncTransport::getReadCallback ( ) const

overridevirtual

Implements folly::AsyncTransportWrapper.

Definition at line 225 of file TestAsyncTransport.cpp.

References readCallback_.

                                           {
   return dynamic_cast<TestAsyncTransport::ReadCallback*>(readCallback_);
 }

uint32_t TestAsyncTransport::getSendTimeout ( ) const

overridevirtual

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 380 of file TestAsyncTransport.cpp.

References sendTimeout_.

                                          {
   return sendTimeout_;
 }

std::deque< std::shared_ptr<WriteEvent> >* TestAsyncTransport::getWriteEvents ( )

inline

Definition at line 101 of file TestAsyncTransport.h.

References writeEvents_.

                                                           {
     return &writeEvents_;
   }

bool TestAsyncTransport::good ( ) const

overridevirtual

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 331 of file TestAsyncTransport.cpp.

References kStateOpen, readState_, and writesAllowed().

                                {
   return (readState_ == kStateOpen && writesAllowed());
 }

bool TestAsyncTransport::isDetachable ( ) const

overridevirtual

Determine if the transport can be detached.

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

Implements folly::AsyncTransport.

Definition at line 365 of file TestAsyncTransport.cpp.

                                        {
   return true;
 }

bool TestAsyncTransport::isEorTrackingEnabled ( ) const

inlineoverridevirtual

Returns: True iff end of record tracking is enabled

Implements folly::AsyncTransport.

Definition at line 117 of file TestAsyncTransport.h.

117 { return false; }

TestAsyncTransport& TestAsyncTransport::operator= ( TestAsyncTransport const & )

private

Referenced by writesAllowed().

void TestAsyncTransport::pauseWrites ( )

Definition at line 385 of file TestAsyncTransport.cpp.

References kStateOpen, kStatePaused, and writeState_.

                                 {
   if (writeState_ != kStateOpen) {
     LOG(FATAL) << "cannot pause writes on non-open transport; state=" <<
       writeState_;
   }
   writeState_ = kStatePaused;
 }

bool TestAsyncTransport::readable ( ) const

overridevirtual

Determine if the transport is readable or not.

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

Implements folly::AsyncTransport.

Definition at line 336 of file TestAsyncTransport.cpp.

                                    {
   return false;
 }

void TestAsyncTransport::resumeWrites ( )

Definition at line 394 of file TestAsyncTransport.cpp.

References kStateOpen, kStatePaused, pendingWriteEvents_, writeEvents_, and writeState_.

                                  {
   if (writeState_ != kStatePaused) {
     LOG(FATAL) << "cannot resume writes on non-paused transport; state=" <<
       writeState_;
   }
   writeState_ = kStateOpen;
   for (auto event = pendingWriteEvents_.begin();
        event != pendingWriteEvents_.end() && writeState_ == kStateOpen;
        event = pendingWriteEvents_.begin()) {
     writeEvents_.push_back(event->first);
     pendingWriteEvents_.pop_front();
     event->second->writeSuccess();
   }
 }

void TestAsyncTransport::scheduleNextReadEvent ( proxygen::TimePoint now )

private

Definition at line 508 of file TestAsyncTransport.cpp.

References fireNextReadEvent(), nextReadEventTime_, and folly::AsyncTimeout::scheduleTimeout().

Referenced by addReadEvent(), setReadCB(), startReadEvents(), and writesAllowed().

                                                        {
   if (nextReadEventTime_ <= now) {
     fireNextReadEvent();
   } else {
     scheduleTimeout(std::chrono::duration_cast<std::chrono::milliseconds>
                     (nextReadEventTime_ - now));
   }
 }

void TestAsyncTransport::setEorTracking ( bool )

inlineoverridevirtual

Implements folly::AsyncTransport.

Definition at line 118 of file TestAsyncTransport.h.

118 { return; }

void TestAsyncTransport::setReadCB ( AsyncTransportWrapper::ReadCallback * callback )

override

Definition at line 180 of file TestAsyncTransport.cpp.

References folly::AsyncTimeout::cancelTimeout(), proxygen::getCurrentTime(), kStateClosed, kStateError, kStateOpen, nextReadEventTime_, folly::AsyncSocketException::NOT_OPEN, readCallback_, folly::AsyncReader::ReadCallback::readEOF(), readEvents_, readState_, scheduleNextReadEvent(), and proxygen::timePointInitialized().

                                                                          {
   if (readCallback_ == callback) {
     return;
   }
 
   if (callback == nullptr) {
     cancelTimeout();
     readCallback_ = nullptr;
     return;
   }
 
   bool wasNull = (readCallback_ == nullptr);
 
   if (readState_ == kStateClosed) {
     callback->readEOF();
     return;
   } else if (readState_ == kStateError) {
     folly::AsyncSocketException ex(folly::AsyncSocketException::NOT_OPEN,
                            "setReadCB() called with socket in "
                            "invalid state");
     callback->readErr(ex);
     return;
   }
 
   CHECK_EQ(readState_, kStateOpen);
   readCallback_ = callback;
 
   // If the callback was previously nullptr, read events were paused, so we need
   // to reschedule them now.
   //
   // If it was set before, read events are still scheduled, so we are done now
   // and can return.
   if (!wasNull) {
     return;
   }
 
   if (!proxygen::timePointInitialized(nextReadEventTime_)) {
     // Either readEvents_ is empty, or startReadEvents() hasn't been called yet
     return;
   }
   CHECK(!readEvents_.empty());
   scheduleNextReadEvent(proxygen::getCurrentTime());
 }

void TestAsyncTransport::setSendTimeout ( uint32_t milliseconds )

overridevirtual

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 375 of file TestAsyncTransport.cpp.

References sendTimeout_, and uint32_t.

                                                         {
   sendTimeout_ = milliseconds;
 }

void TestAsyncTransport::shutdownWrite ( )

overridevirtual

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 304 of file TestAsyncTransport.cpp.

References shutdownWriteNow().

                                   {
   shutdownWriteNow();
 }

void TestAsyncTransport::shutdownWriteNow ( )

overridevirtual

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 309 of file TestAsyncTransport.cpp.

References failPendingWrites(), g(), kStateClosed, kStateOpen, kStatePaused, and writeState_.

Referenced by closeNow(), and shutdownWrite().

                                      {
   DestructorGuard g(this);
   failPendingWrites();
   if (writeState_ == kStateOpen ||
       writeState_ == kStatePaused) {
     writeState_ = kStateClosed;
   }
 }

void TestAsyncTransport::startReadEvents ( )

Definition at line 491 of file TestAsyncTransport.cpp.

References proxygen::getCurrentTime(), nextReadEventTime_, now(), prevReadEventTime_, readCallback_, readEvents_, and scheduleNextReadEvent().

                                     {
   auto now = proxygen::getCurrentTime();
   prevReadEventTime_ = now;
 
   if (readEvents_.empty()) {
     return;
   }
   nextReadEventTime_ = prevReadEventTime_ + readEvents_.front()->getDelay();
 
   if (readCallback_ == nullptr) {
     return;
   }
 
   scheduleNextReadEvent(now);
 }

void TestAsyncTransport::timeoutExpired ( )

overrideprivatevirtualnoexcept

timeoutExpired() is invoked when the timeout period has expired.

Implements folly::AsyncTimeout.

Definition at line 636 of file TestAsyncTransport.cpp.

References fireNextReadEvent(), readCallback_, and readEvents_.

Referenced by writesAllowed().

                                             {
   CHECK_NOTNULL(readCallback_);
   CHECK(!readEvents_.empty());
   fireNextReadEvent();
 }

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

override

Definition at line 230 of file TestAsyncTransport.cpp.

References writev().

                                             {
   iovec op;
   op.iov_base = const_cast<void*>(buf);
   op.iov_len = bytes;
   this->writev(callback, &op, 1, flags);
 }

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

override

Definition at line 268 of file TestAsyncTransport.cpp.

References count, folly::IOBuf::data(), i, folly::IOBuf::length(), cpp.ast::next(), folly::IOBuf::next(), uint8_t, and writev().

                                                  {
   size_t count = iob->countChainElements();
   iovec vec[count];
   const IOBuf* head = iob.get();
   const IOBuf* next = head;
   unsigned i = 0;
   do {
     vec[i].iov_base = const_cast<uint8_t *>(next->data());
     vec[i++].iov_len = next->length();
     next = next->next();
   } while (next != head);
   this->writev(callback, vec, count, flags);
 }

bool TestAsyncTransport::writesAllowed ( ) const

inlineprivate

Definition at line 130 of file TestAsyncTransport.h.

References addReadEvent(), failPendingWrites(), fireNextReadEvent(), fireOneReadEvent(), kStateOpen, kStatePaused, folly::pushmi::__adl::noexcept(), now(), operator=(), scheduleNextReadEvent(), TestAsyncTransport(), timeoutExpired(), and writeState_.

Referenced by good(), and writev().

130 { return writeState_ == kStateOpen ||

131 writeState_ == kStatePaused; }

TestAsyncTransport::writeState_

StateEnum writeState_

Definition: TestAsyncTransport.h:153

TestAsyncTransport::kStatePaused

Definition: TestAsyncTransport.h:123

TestAsyncTransport::kStateOpen

Definition: TestAsyncTransport.h:122

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

override

Definition at line 240 of file TestAsyncTransport.cpp.

References corkCount_, eorCount_, folly::isSet(), kStateOpen, kStatePaused, TestAsyncTransport::WriteEvent::newEvent(), pendingWriteEvents_, writeEvents_, writesAllowed(), and writeState_.

Referenced by write(), and writeChain().

                                              {
   if (isSet(flags, WriteFlags::CORK)) {
     corkCount_++;
   } else if (isSet(flags, WriteFlags::EOR)) {
     eorCount_++;
   }
   if (!writesAllowed()) {
     AsyncSocketException ex(AsyncSocketException::NOT_OPEN,
                            "write() called on non-open TestAsyncTransport");
     auto cb = dynamic_cast<WriteCallback*>(callback);
     DCHECK(cb);
     cb->writeErr(0, ex);
     return;
   }
 
   shared_ptr<WriteEvent> event = WriteEvent::newEvent(vec, count);
   if (writeState_ == kStatePaused || pendingWriteEvents_.size() > 0)  {
     pendingWriteEvents_.push_back(std::make_pair(event, callback));
   } else {
     CHECK_EQ(writeState_, kStateOpen);
     writeEvents_.push_back(event);
     callback->writeSuccess();
   }
 }