proxygen: folly::AsyncTimeout Class Reference

#include <AsyncTimeout.h>

Inheritance diagram for folly::AsyncTimeout:

Public Types
typedef TimeoutManager::InternalEnum	InternalEnum

Public Member Functions
	AsyncTimeout (TimeoutManager *timeoutManager)

	AsyncTimeout (EventBase *eventBase)

	AsyncTimeout (TimeoutManager *timeoutManager, InternalEnum internal)

	AsyncTimeout (EventBase *eventBase, InternalEnum internal)

	AsyncTimeout ()

virtual	~AsyncTimeout ()

virtual void	timeoutExpired () noexcept=0

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 ()

Static Public Member Functions
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)

Static Private Member Functions
static void	libeventCallback (libevent_fd_t fd, short events, void *arg)

Private Attributes
struct event	event_

TimeoutManager *	timeoutManager_

std::shared_ptr< RequestContext >	context_

Detailed Description

AsyncTimeout is used to asynchronously wait for a timeout to occur.

Definition at line 36 of file AsyncTimeout.h.

Member Typedef Documentation

typedef TimeoutManager::InternalEnum folly::AsyncTimeout::InternalEnum

Definition at line 38 of file AsyncTimeout.h.

Constructor & Destructor Documentation

folly::AsyncTimeout::AsyncTimeout ( TimeoutManager * timeoutManager )

explicit

Create a new AsyncTimeout object, driven by the specified TimeoutManager.

Definition at line 27 of file AsyncTimeout.cpp.

References folly::TimeoutManager::attachTimeoutManager(), event_, folly::folly_event_set(), libeventCallback(), folly::TimeoutManager::NORMAL, and timeoutManager_.

     : timeoutManager_(timeoutManager) {
   folly_event_set(
       &event_, -1, EV_TIMEOUT, &AsyncTimeout::libeventCallback, this);
   event_.ev_base = nullptr;
   timeoutManager_->attachTimeoutManager(
       this, TimeoutManager::InternalEnum::NORMAL);
 }

folly::AsyncTimeout::AsyncTimeout ( EventBase * eventBase )

explicit

Definition at line 36 of file AsyncTimeout.cpp.

References folly::TimeoutManager::attachTimeoutManager(), event_, folly::folly_event_set(), libeventCallback(), folly::TimeoutManager::NORMAL, and timeoutManager_.

                                                : timeoutManager_(eventBase) {
   folly_event_set(
       &event_, -1, EV_TIMEOUT, &AsyncTimeout::libeventCallback, this);
   event_.ev_base = nullptr;
   if (eventBase) {
     timeoutManager_->attachTimeoutManager(
         this, TimeoutManager::InternalEnum::NORMAL);
   }
 }

folly::AsyncTimeout::AsyncTimeout	(	TimeoutManager *	timeoutManager,
		InternalEnum	internal
	)

Create a new internal AsyncTimeout object.

Internal timeouts are like regular timeouts, but will not stop the TimeoutManager loop from exiting if the only remaining events are internal timeouts.

This is useful for implementing fallback timeouts to abort the TimeoutManager loop if the other events have not been processed within a specified time period: if the event loop takes too long the timeout will fire and can stop the event loop. However, if all other events complete, the event loop will exit even though the internal timeout is still installed.

Definition at line 46 of file AsyncTimeout.cpp.

References folly::TimeoutManager::attachTimeoutManager(), event_, folly::folly_event_set(), libeventCallback(), and timeoutManager_.

     : timeoutManager_(timeoutManager) {
   folly_event_set(
       &event_, -1, EV_TIMEOUT, &AsyncTimeout::libeventCallback, this);
   event_.ev_base = nullptr;
   timeoutManager_->attachTimeoutManager(this, internal);
 }

folly::AsyncTimeout::AsyncTimeout	(	EventBase *	eventBase,
		InternalEnum	internal
	)

Definition at line 56 of file AsyncTimeout.cpp.

References folly::TimeoutManager::attachTimeoutManager(), event_, folly::folly_event_set(), libeventCallback(), and timeoutManager_.

     : timeoutManager_(eventBase) {
   folly_event_set(
       &event_, -1, EV_TIMEOUT, &AsyncTimeout::libeventCallback, this);
   event_.ev_base = nullptr;
   timeoutManager_->attachTimeoutManager(this, internal);
 }

folly::AsyncTimeout::AsyncTimeout ( )

Create a new AsyncTimeout object, not yet assigned to a TimeoutManager.

attachEventBase() must be called prior to scheduling the timeout.

Definition at line 64 of file AsyncTimeout.cpp.

References event_, folly::folly_event_set(), and libeventCallback().

                            : timeoutManager_(nullptr) {
   folly_event_set(
       &event_, -1, EV_TIMEOUT, &AsyncTimeout::libeventCallback, this);
   event_.ev_base = nullptr;
 }

folly::AsyncTimeout::~AsyncTimeout ( )

virtual

AsyncTimeout destructor.

The timeout will be automatically cancelled if it is running.

Definition at line 70 of file AsyncTimeout.cpp.

References cancelTimeout().

                             {
   cancelTimeout();
 }

Member Function Documentation

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

Definition at line 106 of file AsyncTimeout.cpp.

References attachTimeoutManager().

Referenced by fizz::AsyncFizzBase::attachEventBase(), folly::AsyncSocket::attachEventBase(), folly::AsyncSSLSocket::attachEventBase(), and folly::HHWheelTimer::isDetachable().

                            {
   attachTimeoutManager(eventBase, internal);
 }

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

Attach the timeout to a TimeoutManager.

This may only be called if the timeout is not currently attached to a TimeoutManager (either by using the default constructor, or by calling detachTimeoutManager()).

This method must be invoked in the TimeoutManager's thread.

The internal parameter specifies if this timeout should be treated as an internal event. TimeoutManager::loop() will return when there are no more non-internal events remaining.

Definition at line 95 of file AsyncTimeout.cpp.

References folly::TimeoutManager::attachTimeoutManager(), folly::TimeoutManager::isInTimeoutManagerThread(), and timeoutManager_.

Referenced by attachEventBase(), fizz::AsyncFizzBase::attachTimeoutManager(), and folly::AsyncSSLSocket::attachTimeoutManager().

                            {
   // This also implies no timeout is scheduled.
   assert(timeoutManager_ == nullptr);
   assert(timeoutManager->isInTimeoutManagerThread());
   timeoutManager_ = timeoutManager;
 
   timeoutManager_->attachTimeoutManager(this, internal);
 }

void folly::AsyncTimeout::cancelTimeout ( )

Cancel the timeout, if it is running.

Definition at line 84 of file AsyncTimeout.cpp.

References folly::TimeoutManager::cancelTimeout(), context_, isScheduled(), and timeoutManager_.

Referenced by fizz::AsyncFizzBase::cancelHandshakeTimeout(), folly::AsyncSSLSocket::closeNow(), folly::AsyncSocket::closeNow(), folly::AsyncSSLSocket::failHandshake(), folly::AsyncSSLSocket::handleConnect(), folly::AsyncSocket::handleConnect(), folly::AsyncSocket::handleWrite(), proxygen::AsyncTimeoutSet::headChanged(), folly::AsyncSSLSocket::invokeConnectErr(), folly::AsyncSSLSocket::invokeConnectSuccess(), folly::AsyncSSLSocket::invokeHandshakeCB(), folly::AsyncServerSocket::pauseAccepting(), folly::HHWheelTimer::scheduleNextTimeout(), TestAsyncTransport::setReadCB(), folly::AsyncSocket::setSendTimeout(), folly::AsyncSocket::shutdownWriteNow(), folly::AsyncSocket::startFail(), folly::TEST(), and ~AsyncTimeout().

                                  {
   if (isScheduled()) {
     timeoutManager_->cancelTimeout(this);
     context_.reset();
   }
 }

void folly::AsyncTimeout::detachEventBase ( )

Definition at line 126 of file AsyncTimeout.cpp.

References detachTimeoutManager().

Referenced by fizz::AsyncFizzBase::detachEventBase(), folly::AsyncSocket::detachEventBase(), folly::AsyncSSLSocket::detachEventBase(), folly::HHWheelTimer::isDetachable(), and TEST_F().

                                    {
   detachTimeoutManager();
 }

void folly::AsyncTimeout::detachTimeoutManager ( )

Detach the timeout from its TimeoutManager.

This may only be called when the timeout is not running. Once detached, the timeout may not be scheduled again until it is re-attached to a EventBase by calling attachEventBase().

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

Definition at line 112 of file AsyncTimeout.cpp.

References folly::TimeoutManager::detachTimeoutManager(), folly::FATAL, isScheduled(), and timeoutManager_.

Referenced by detachEventBase(), fizz::AsyncFizzBase::detachTimeoutManager(), and folly::AsyncSSLSocket::detachTimeoutManager().

                                         {
   // Only allow the event base to be changed if the timeout is not
   // currently installed.
   if (isScheduled()) {
     // Programmer bug.  Abort the program.
     LOG(FATAL) << "detachEventBase() called on scheduled timeout; aborting";
   }
 
   if (timeoutManager_) {
     timeoutManager_->detachTimeoutManager(this);
     timeoutManager_ = nullptr;
   }
 }

struct event* folly::AsyncTimeout::getEvent ( )

inline

Returns the internal handle to the event

Definition at line 150 of file AsyncTimeout.h.

References event_, libeventCallback(), make(), schedule(), and folly::detail::timeout.

Referenced by folly::EventBase::attachTimeoutManager(), folly::EventBase::cancelTimeout(), folly::EventBase::detachTimeoutManager(), folly::EventBase::scheduleTimeout(), TimeoutTest::setClock(), and TimeoutTest::SetUp().

                            {
     return &event_;
   }

const TimeoutManager* folly::AsyncTimeout::getTimeoutManager ( )

inline

Definition at line 143 of file AsyncTimeout.h.

References timeoutManager_.

Referenced by folly::HHWheelTimer::isDetachable().

                                             {
     return timeoutManager_;
   }

bool folly::AsyncTimeout::isScheduled ( ) const

Returns true if the timeout is currently scheduled.

Definition at line 91 of file AsyncTimeout.cpp.

References event_, and folly::EventUtil::isEventRegistered().

Referenced by cancelTimeout(), folly::AsyncSSLSocket::closeNow(), detachTimeoutManager(), folly::AsyncSSLSocket::failHandshake(), folly::AsyncSSLSocket::handleConnect(), folly::AsyncSocket::handleWrite(), folly::AsyncSSLSocket::invalidState(), folly::AsyncSSLSocket::invokeConnectErr(), folly::AsyncSSLSocket::invokeHandshakeCB(), fizz::AsyncFizzBase::isDetachable(), folly::HHWheelTimer::isDetachable(), folly::AsyncSocket::isDetachable(), folly::AsyncSSLSocket::isDetachable(), and folly::HHWheelTimer::scheduleNextTimeout().

                                      {
   return EventUtil::isEventRegistered(&event_);
 }

void folly::AsyncTimeout::libeventCallback	(	libevent_fd_t	fd,
		short	events,
		void *	arg
	)

staticprivate

Definition at line 130 of file AsyncTimeout.cpp.

References folly::TimeoutManager::bumpHandlingTime(), context_, event_, folly::event_ref_flags(), folly::libeventFdToFd(), folly::detail::timeout, timeoutExpired(), and timeoutManager_.

Referenced by AsyncTimeout(), and getEvent().

                                                                              {
   AsyncTimeout* timeout = reinterpret_cast<AsyncTimeout*>(arg);
   assert(libeventFdToFd(fd) == -1);
   assert(events == EV_TIMEOUT);
   // prevent unused variable warnings
   (void)fd;
   (void)events;
 
   // double check that ev_flags gets reset when the timeout is not running
   assert((event_ref_flags(&timeout->event_) & ~EVLIST_INTERNAL) == EVLIST_INIT);
 
   // this can't possibly fire if timeout->eventBase_ is nullptr
   timeout->timeoutManager_->bumpHandlingTime();
 
   RequestContextScopeGuard rctx(timeout->context_);
 
   timeout->timeoutExpired();
 }

template<typename TCallback >

std::unique_ptr< AsyncTimeout > folly::AsyncTimeout::make	(	TimeoutManager &	manager,
		TCallback &&	callback
	)

static

Convenience function that wraps a function object as an AsyncTimeout instance and returns the wrapper.

Specially useful when using lambdas as AsyncTimeout observers.

Example:

void foo(TimeoutManager &manager) { std::atomic_bool done = false;

auto observer = AsyncTimeout::make(manager, [&] { std::cout << "hello, world!" << std::endl; done = true; });

observer->scheduleTimeout(std::chrono::seconds(5));

while (!done); // busy wait }

Author: : Marcelo Juchem marce.nosp@m.lo@f.nosp@m.b.com

Definition at line 261 of file AsyncTimeout.h.

Referenced by getEvent(), schedule(), and folly::TEST().

                           {
   return std::unique_ptr<AsyncTimeout>(
       new detail::async_timeout_wrapper<typename std::decay<TCallback>::type>(
           std::addressof(manager), std::forward<TCallback>(callback)));
 }

template<typename TCallback >

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

static

Convenience function that wraps a function object as an AsyncTimeout instance and returns the wrapper after scheduling it using the given TimeoutManager.

This is equivalent to calling make_async_timeout followed by a scheduleTimeout on the resulting wrapper.

Specially useful when using lambdas as AsyncTimeout observers.

Example:

void foo(TimeoutManager &manager) { std::atomic_bool done = false;

auto observer = AsyncTimeout::schedule( std::chrono::seconds(5), manager, [&] { std::cout << "hello, world!" << std::endl; done = true; } );

while (!done); // busy wait }

Author: : Marcelo Juchem marce.nosp@m.lo@f.nosp@m.b.com

Definition at line 270 of file AsyncTimeout.h.

References make().

Referenced by getEvent(), and folly::TEST().

                           {
   auto wrapper = AsyncTimeout::make(manager, std::forward<TCallback>(callback));
   wrapper->scheduleTimeout(timeout);
   return wrapper;
 }

bool folly::AsyncTimeout::scheduleTimeout ( uint32_t milliseconds )

Schedule the timeout to fire in the specified number of milliseconds.

After the specified number of milliseconds has elapsed, timeoutExpired() will be invoked by the TimeoutManager's main loop.

If the timeout is already running, it will be rescheduled with the new timeout value.

Parameters

milliseconds The timeout duration, in milliseconds.

Returns: Returns true if the timeout was successfully scheduled, and false if an error occurred. After an error, the timeout is always unscheduled, even if scheduleTimeout() was just rescheduling an existing timeout.

Definition at line 80 of file AsyncTimeout.cpp.

Referenced by folly::AsyncServerSocket::enterBackoff(), TestAsyncTransport::fireNextReadEvent(), folly::AsyncSocket::handleWrite(), proxygen::AsyncTimeoutSet::headChanged(), folly::MemoryIdlerTimeout::runLoopCallback(), folly::AsyncSocket::scheduleConnectTimeout(), TestAsyncTransport::scheduleNextReadEvent(), folly::HHWheelTimer::scheduleNextTimeout(), folly::AsyncSSLSocket::Timeout::scheduleTimeout(), proxygen::AsyncTimeoutSet::scheduleTimeout(), folly::AsyncSocket::setSendTimeout(), fizz::server::SlidingBloomReplayCache::SlidingBloomReplayCache(), fizz::AsyncFizzBase::startHandshakeTimeout(), TEST(), fizz::server::SlidingBloomReplayCache::timeoutExpired(), proxygen::AsyncTimeoutSet::timeoutExpired(), and folly::AsyncSocket::writeImpl().

                                                         {
   return scheduleTimeout(TimeoutManager::timeout_type(milliseconds));
 }

bool folly::AsyncTimeout::scheduleTimeout ( TimeoutManager::timeout_type timeout )

Definition at line 74 of file AsyncTimeout.cpp.

References context_, folly::RequestContext::saveContext(), folly::TimeoutManager::scheduleTimeout(), and timeoutManager_.

                                                                      {
   assert(timeoutManager_ != nullptr);
   context_ = RequestContext::saveContext();
   return timeoutManager_->scheduleTimeout(this, timeout);
 }

virtual void folly::AsyncTimeout::timeoutExpired ( )

pure virtualnoexcept

Member Data Documentation

std::shared_ptr<RequestContext> folly::AsyncTimeout::context_

private

Definition at line 231 of file AsyncTimeout.h.

Referenced by cancelTimeout(), libeventCallback(), and scheduleTimeout().

struct event folly::AsyncTimeout::event_

private

Definition at line 221 of file AsyncTimeout.h.

Referenced by AsyncTimeout(), getEvent(), isScheduled(), and libeventCallback().

TimeoutManager* folly::AsyncTimeout::timeoutManager_

private

Definition at line 228 of file AsyncTimeout.h.

Referenced by AsyncTimeout(), attachTimeoutManager(), cancelTimeout(), detachTimeoutManager(), getTimeoutManager(), libeventCallback(), and scheduleTimeout().

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

proxygen/folly/folly/io/async/AsyncTimeout.h
proxygen/folly/folly/io/async/AsyncTimeout.cpp

Public Types

Public Member Functions

Static Public Member Functions

Static Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation