wangle::EvbHandshakeHelper Class Reference

#include <EvbHandshakeHelper.h>

Inheritance diagram for wangle::EvbHandshakeHelper:

Public Member Functions
	EvbHandshakeHelper (AcceptorHandshakeHelper::UniquePtr helper, folly::EventBase *handshakeEvb)
void	start (folly::AsyncSSLSocket::UniquePtr sock, AcceptorHandshakeHelper::Callback *callback) noexceptoverride
void	dropConnection (SSLErrorEnum reason=SSLErrorEnum::NO_ERROR) override
virtual void	connectionReady (folly::AsyncTransportWrapper::UniquePtr transport, std::string nextProtocol, SecureTransportType secureTransportType, folly::Optional< SSLErrorEnum > sslErr) noexceptoverride
virtual void	connectionError (folly::AsyncTransportWrapper *transport, folly::exception_wrapper ex, folly::Optional< SSLErrorEnum > sslErr) noexceptoverride
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 wangle::AcceptorHandshakeHelper::Callback
virtual	~Callback ()=default

Protected Types
enum	HandshakeState : unsigned { HandshakeState::Invalid, HandshakeState::Started, HandshakeState::Dropped, HandshakeState::Callback }

Protected Member Functions
	~EvbHandshakeHelper ()
Protected Member Functions inherited from folly::DelayedDestruction
	~DelayedDestruction () override=default
	DelayedDestruction ()
Protected Member Functions inherited from folly::DelayedDestructionBase
	DelayedDestructionBase ()
uint32_t	getDestructorGuardCount () const

Protected Attributes
AcceptorHandshakeHelper::UniquePtr	helper_
AcceptorHandshakeHelper::Callback *	callback_
folly::EventBase *	originalEvb_
folly::EventBase *	handshakeEvb_
std::atomic< HandshakeState >	state_ {HandshakeState::Invalid}
folly::Optional< folly::DelayedDestruction::DestructorGuard >	dropConnectionGuard_

Private Member Functions
std::pair< bool, HandshakeState >	tryTransition (HandshakeState expected, HandshakeState next)

Additional Inherited Members
Public Types inherited from wangle::AcceptorHandshakeHelper
using	UniquePtr = std::unique_ptr< AcceptorHandshakeHelper, folly::DelayedDestruction::Destructor >

Detailed Description

Wraps an existing AcceptorHandshakeHelper and callback. Performs handshakes under a specified handshake eventbase and delivers callback notifications in the original EventBase.

An example use case of this class would be to offload TLS handshakes under a separate EventBase thread rather than the Acceptor thread.

Definition at line 34 of file EvbHandshakeHelper.h.

Member Enumeration Documentation

enum wangle::EvbHandshakeHelper::HandshakeState : unsigned

strongprotected

Enumerator
Invalid
Started
Dropped
Callback

Definition at line 63 of file EvbHandshakeHelper.h.

                            : unsigned {
    Invalid,
    Started,
    Dropped,
    Callback,
  };

Constructor & Destructor Documentation

wangle::EvbHandshakeHelper::EvbHandshakeHelper ( AcceptorHandshakeHelper::UniquePtr  helper, folly::EventBase *  handshakeEvb  )

inlineexplicit

Definition at line 37 of file EvbHandshakeHelper.h.

References connectionError(), connectionReady(), dropConnection(), wangle::NO_ERROR, folly::pushmi::__adl::noexcept(), start(), and string.

      : helper_(std::move(helper)),
        originalEvb_(nullptr),
        handshakeEvb_(handshakeEvb) {}

wangle::EvbHandshakeHelper::~EvbHandshakeHelper ( )

protected

Definition at line 166 of file EvbHandshakeHelper.cpp.

                                        {
  VLOG(5) << "evbhandshakehelper is destroyed";
}

Member Function Documentation

void wangle::EvbHandshakeHelper::connectionError ( folly::AsyncTransportWrapper *  transport, folly::exception_wrapper  ex, folly::Optional< SSLErrorEnum >  sslErr  )

overridevirtualnoexcept

Called if an error was encountered while performing handshake.

If sslErr is set, Acceptor::updateSSLStats will be called.

Implements wangle::AcceptorHandshakeHelper::Callback.

Definition at line 126 of file EvbHandshakeHelper.cpp.

References Callback, callback_, folly::Optional< Value >::clear(), wangle::AcceptorHandshakeHelper::Callback::connectionError(), dropConnectionGuard_, handshakeEvb_, folly::Optional< Value >::hasValue(), helper_, folly::gen::move, originalEvb_, folly::EventBase::runInEventBaseThread(), Started, and tryTransition().

Referenced by EvbHandshakeHelper().

                                                 {
  DCHECK(transport->getEventBase() == handshakeEvb_);

  auto transition =
      tryTransition(HandshakeState::Started, HandshakeState::Callback);
  if (!transition.first) {
    VLOG(5) << "Ignoring call to connectionError(), expected state to be "
            << static_cast<unsigned>(HandshakeState::Started)
            << " but actual state was "
            << static_cast<unsigned>(transition.second);
    return;
  }

  helper_.reset();
  originalEvb_->runInEventBaseThread(
      [this, sslErr, ex = std::move(ex)]() mutable {
        DCHECK(callback_);
        VLOG(5) << "calling underlying callback connectionError";

        // If a dropConnection call occured by the time this lambda runs, we
        // don't want to fire the callback. (See Case 2)
        if (dropConnectionGuard_.hasValue()) {
          dropConnectionGuard_.clear();
          return;
        }
        callback_->connectionError(nullptr, std::move(ex), sslErr);
      });
}

void wangle::EvbHandshakeHelper::connectionReady ( folly::AsyncTransportWrapper::UniquePtr  transport, std::string  nextProtocol, SecureTransportType  secureTransportType, folly::Optional< SSLErrorEnum >  sslErr  )

overridevirtualnoexcept

Called after handshake has been completed successfully.

If sslErr is set, Acceptor::updateSSLStats will be called.

Implements wangle::AcceptorHandshakeHelper::Callback.

Definition at line 81 of file EvbHandshakeHelper.cpp.

References Callback, callback_, folly::Optional< Value >::clear(), wangle::AcceptorHandshakeHelper::Callback::connectionReady(), dropConnectionGuard_, handshakeEvb_, folly::Optional< Value >::hasValue(), folly::gen::move, originalEvb_, folly::EventBase::runInEventBaseThread(), Started, and tryTransition().

Referenced by EvbHandshakeHelper().

                                                 {
  DCHECK_EQ(transport->getEventBase(), handshakeEvb_);

  auto transition =
      tryTransition(HandshakeState::Started, HandshakeState::Callback);
  if (!transition.first) {
    VLOG(5) << "Ignoring call to connectionReady(), expected state to be "
            << static_cast<unsigned>(HandshakeState::Started)
            << " but actual state was "
            << static_cast<unsigned>(transition.second);
    return;
  }

  transport->detachEventBase();

  originalEvb_->runInEventBaseThread([
    this,
    secureTransportType,
    sslErr,
    transport = std::move(transport),
    nextProtocol = std::move(nextProtocol)
  ]() mutable {
    DCHECK(callback_);
    VLOG(5) << "calling underlying callback connectionReady";
    transport->attachEventBase(originalEvb_);

    // If a dropConnection call occured by the time this lambda runs, we don't
    // want to fire the callback. (See Case 2)
    if (dropConnectionGuard_.hasValue()) {
      dropConnectionGuard_.clear();
      return;
    }

    callback_->connectionReady(
        std::move(transport),
        std::move(nextProtocol),
        secureTransportType,
        sslErr);
  });
}

void wangle::EvbHandshakeHelper::dropConnection ( SSLErrorEnum  reason = SSLErrorEnum::NO_ERROR )

overridevirtual

Implements wangle::AcceptorHandshakeHelper.

Definition at line 42 of file EvbHandshakeHelper.cpp.

References callback_, folly::Optional< Value >::clear(), wangle::AcceptorHandshakeHelper::Callback::connectionError(), folly::EventBase::dcheckIsInEventBaseThread(), dropConnectionGuard_, Dropped, folly::Optional< Value >::emplace(), handshakeEvb_, helper_, originalEvb_, folly::EventBase::runInEventBaseThread(), Started, and tryTransition().

Referenced by EvbHandshakeHelper().

                                                           {
  CHECK(originalEvb_);
  originalEvb_->dcheckIsInEventBaseThread();

  auto transition =
      tryTransition(HandshakeState::Started, HandshakeState::Dropped);

  // Regardless of whether or not we win the race or not, we will set
  // dropConnectionGuard_ (see case 2) to let a potential C' know that the
  // connection was dropped. C', seeing this, is responsible for clearing
  // the dropConnectionGuard.
  dropConnectionGuard_.emplace(this);
  callback_->connectionError(
      nullptr,
      folly::make_exception_wrapper<std::runtime_error>("connection dropped"),
      reason);

  if (transition.first) {
    // If we win the race to update the state, though, we are responsible
    // for ensuring that dropConnection() is called on the handshake thread,
    // and we are also the one responsible for clearing the dropConnectionGuard_
    // that we set earlier.
    handshakeEvb_->runInEventBaseThread([this, reason] {
      VLOG(5) << "callback has not been received. dropConnection "
              << "calling underlying helper";

      helper_->dropConnection(reason);

      // We need to ensure that the transport is destroyed in the handshake
      // thread since the transport is currently attached to the handshake's
      // event base.
      helper_.reset();

      originalEvb_->runInEventBaseThread(
          [this] { dropConnectionGuard_.clear(); });
    });
  }
}

void wangle::EvbHandshakeHelper::start ( folly::AsyncSSLSocket::UniquePtr  sock, AcceptorHandshakeHelper::Callback *  callback  )

overridevirtualnoexcept

Implements wangle::AcceptorHandshakeHelper.

Definition at line 20 of file EvbHandshakeHelper.cpp.

References callback_, testing::internal::Invalid(), and folly::gen::move.

Referenced by EvbHandshakeHelper().

                                                        {
  auto transition =
      tryTransition(HandshakeState::Invalid, HandshakeState::Started);
  if (!transition.first) {
    VLOG(5) << "Ignoring call to start(), since state is currently "
            << static_cast<unsigned>(transition.second);
  }

  callback_ = callback;
  originalEvb_ = sock->getEventBase();
  CHECK(originalEvb_);

  sock->detachEventBase();
  handshakeEvb_->runInEventBaseThread(
      [ this, sock = std::move(sock) ]() mutable {
        sock->attachEventBase(handshakeEvb_);
        helper_->start(std::move(sock), this);
      });
}

std::pair< bool, EvbHandshakeHelper::HandshakeState > wangle::EvbHandshakeHelper::tryTransition ( HandshakeState  expected, HandshakeState  next  )

private

Definition at line 159 of file EvbHandshakeHelper.cpp.

References state_.

Referenced by connectionError(), connectionReady(), and dropConnection().

                         {
  bool res = state_.compare_exchange_strong(expected, next);
  return std::make_pair(res, expected);
}

Member Data Documentation

AcceptorHandshakeHelper::Callback* wangle::EvbHandshakeHelper::callback_

protected

Definition at line 73 of file EvbHandshakeHelper.h.

Referenced by connectionError(), connectionReady(), and dropConnection().

folly::Optional<folly::DelayedDestruction::DestructorGuard> wangle::EvbHandshakeHelper::dropConnectionGuard_

protected

Definition at line 210 of file EvbHandshakeHelper.h.

Referenced by connectionError(), connectionReady(), and dropConnection().

folly::EventBase* wangle::EvbHandshakeHelper::handshakeEvb_

protected

Definition at line 76 of file EvbHandshakeHelper.h.

Referenced by connectionError(), connectionReady(), and dropConnection().

AcceptorHandshakeHelper::UniquePtr wangle::EvbHandshakeHelper::helper_

protected

Definition at line 72 of file EvbHandshakeHelper.h.

Referenced by connectionError(), and dropConnection().

folly::EventBase* wangle::EvbHandshakeHelper::originalEvb_

protected

Definition at line 75 of file EvbHandshakeHelper.h.

Referenced by connectionError(), connectionReady(), and dropConnection().

std::atomic<HandshakeState> wangle::EvbHandshakeHelper::state_ {HandshakeState::Invalid}

protected

Definition at line 204 of file EvbHandshakeHelper.h.

Referenced by tryTransition().

---

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

• proxygen/wangle/wangle/acceptor/EvbHandshakeHelper.h
• proxygen/wangle/wangle/acceptor/EvbHandshakeHelper.cpp