folly::AsyncServerSocket::RemoteAcceptor Class Reference

Inheritance diagram for folly::AsyncServerSocket::RemoteAcceptor:

Public Member Functions
	RemoteAcceptor (AcceptCallback *callback, ConnectionEventCallback *connectionEventCallback)
	~RemoteAcceptor () override=default
void	start (EventBase *eventBase, uint32_t maxAtOnce, uint32_t maxInQueue)
void	stop (EventBase *eventBase, AcceptCallback *callback)
void	messageAvailable (QueueMessage &&message) noexceptoverride
NotificationQueue< QueueMessage > *	getQueue ()

Private Attributes
AcceptCallback *	callback_
ConnectionEventCallback *	connectionEventCallback_
NotificationQueue< QueueMessage >	queue_

Additional Inherited Members
Private Types inherited from folly::NotificationQueue< MessageT >::Consumer
enum	: uint16_t { kDefaultMaxReadAtOnce = 10 }
Private Member Functions inherited from folly::NotificationQueue< MessageT >::Consumer
	Consumer ()
virtual void	messageAvailable (MessageT &&message) noexcept=0
void	startConsuming (EventBase *eventBase, NotificationQueue *queue)
void	startConsumingInternal (EventBase *eventBase, NotificationQueue *queue)
void	stopConsuming ()
bool	consumeUntilDrained (size_t *numConsumed=nullptr) noexcept
NotificationQueue *	getCurrentQueue () const
void	setMaxReadAtOnce (uint32_t maxAtOnce)
uint32_t	getMaxReadAtOnce () const
EventBase *	getEventBase ()
void	handlerReady (uint16_t events) noexceptoverride
template<typename TCallback >
std::unique_ptr< typename NotificationQueue< MessageT >::Consumer, DelayedDestruction::Destructor >	make (TCallback &&callback)
void	destroy () override
	~Consumer () override
Private Member Functions inherited from folly::DelayedDestruction
bool	getDestroyPending () const
	~DelayedDestruction () override=default
	DelayedDestruction ()
Private Member Functions inherited from folly::DelayedDestructionBase
virtual	~DelayedDestructionBase ()=default
	DelayedDestructionBase ()
uint32_t	getDestructorGuardCount () const
Static Private Member Functions inherited from folly::NotificationQueue< MessageT >::Consumer
template<typename TCallback >
static std::unique_ptr< Consumer, DelayedDestruction::Destructor >	make (TCallback &&callback)

Detailed Description

A class to receive notifications to invoke AcceptCallback objects in other EventBase threads.

A RemoteAcceptor object is created for each AcceptCallback that is installed in a separate EventBase thread. The RemoteAcceptor receives notification of new sockets via a NotificationQueue, and then invokes the AcceptCallback.

Definition at line 761 of file AsyncServerSocket.h.

Constructor & Destructor Documentation

folly::AsyncServerSocket::RemoteAcceptor::RemoteAcceptor ( AcceptCallback *  callback, ConnectionEventCallback *  connectionEventCallback  )

inlineexplicit

Definition at line 763 of file AsyncServerSocket.h.

References folly::pushmi::__adl::noexcept(), start, stop(), and uint32_t.

        : callback_(callback),
          connectionEventCallback_(connectionEventCallback) {}

folly::AsyncServerSocket::RemoteAcceptor::~RemoteAcceptor ( )

overridedefault

Member Function Documentation

NotificationQueue<QueueMessage>* folly::AsyncServerSocket::RemoteAcceptor::getQueue ( )

inline

Definition at line 776 of file AsyncServerSocket.h.

Referenced by folly::AsyncServerSocket::dispatchError(), and folly::AsyncServerSocket::dispatchSocket().

                                                {
      return &queue_;
    }

void folly::AsyncServerSocket::RemoteAcceptor::messageAvailable ( QueueMessage &&  message )

overridenoexcept

Definition at line 114 of file AsyncServerSocket.cpp.

References folly::AsyncServerSocket::AcceptCallback::acceptError(), callback_, folly::AsyncServerSocket::AcceptCallback::connectionAccepted(), connectionEventCallback_, folly::AsyncServerSocket::MSG_ERROR, folly::AsyncServerSocket::MSG_NEW_CONN, and folly::AsyncServerSocket::ConnectionEventCallback::onConnectionDequeuedByAcceptorCallback().

                                 {
  switch (msg.type) {
    case MessageType::MSG_NEW_CONN: {
      if (connectionEventCallback_) {
        connectionEventCallback_->onConnectionDequeuedByAcceptorCallback(
            msg.fd, msg.address);
      }
      callback_->connectionAccepted(msg.fd, msg.address);
      break;
    }
    case MessageType::MSG_ERROR: {
      std::runtime_error ex(msg.msg);
      callback_->acceptError(ex);
      break;
    }
    default: {
      LOG(ERROR) << "invalid accept notification message type "
                 << int(msg.type);
      std::runtime_error ex(
          "received invalid accept notification message type");
      callback_->acceptError(ex);
    }
  }
}

void folly::AsyncServerSocket::RemoteAcceptor::start	(	EventBase *	eventBase,
		uint32_t	maxAtOnce,
		uint32_t	maxInQueue
	)

Definition at line 82 of file AsyncServerSocket.cpp.

References queue_, folly::EventBase::runInEventBaseThread(), and folly::NotificationQueue< MessageT >::Consumer::setMaxReadAtOnce().

Referenced by folly::AsyncServerSocket::addAcceptCallback().

                         {
  setMaxReadAtOnce(maxAtOnce);
  queue_.setMaxQueueSize(maxInQueue);

  if (!eventBase->runInEventBaseThread([=]() {
        callback_->acceptStarted();
        this->startConsuming(eventBase, &queue_);
      })) {
    throw std::invalid_argument(
        "unable to start waiting on accept "
        "notification queue in the specified "
        "EventBase thread");
  }
}

void folly::AsyncServerSocket::RemoteAcceptor::stop	(	EventBase *	eventBase,
		AcceptCallback *	callback
	)

Definition at line 100 of file AsyncServerSocket.cpp.

References folly::EventBase::runInEventBaseThread().

Referenced by folly::AsyncServerSocket::removeAcceptCallback().

                              {
  if (!eventBase->runInEventBaseThread([=]() {
        callback->acceptStopped();
        delete this;
      })) {
    throw std::invalid_argument(
        "unable to start waiting on accept "
        "notification queue in the specified "
        "EventBase thread");
  }
}

Member Data Documentation

AcceptCallback* folly::AsyncServerSocket::RemoteAcceptor::callback_

private

Definition at line 781 of file AsyncServerSocket.h.

Referenced by messageAvailable().

ConnectionEventCallback* folly::AsyncServerSocket::RemoteAcceptor::connectionEventCallback_

private

Definition at line 782 of file AsyncServerSocket.h.

Referenced by messageAvailable().

NotificationQueue<QueueMessage> folly::AsyncServerSocket::RemoteAcceptor::queue_

private

Definition at line 784 of file AsyncServerSocket.h.

Referenced by start().

---

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

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