wangle::ConnectionManager Class Reference

#include <ConnectionManager.h>

Inheritance diagram for wangle::ConnectionManager:

Classes
class	Callback
class	DrainHelper

Public Types
typedef std::unique_ptr< ConnectionManager, Destructor >	UniquePtr
typedef folly::CountedIntrusiveList< ManagedConnection,&ManagedConnection::listHook_ >::iterator	ConnectionIterator

Public Member Functions
	ConnectionManager (folly::EventBase *eventBase, std::chrono::milliseconds timeout, Callback *callback=nullptr)
void	addConnection (ManagedConnection *connection, bool timeout=false)
void	scheduleTimeout (ManagedConnection *const connection, std::chrono::milliseconds timeout)
void	scheduleTimeout (folly::HHWheelTimer::Callback *callback, std::chrono::milliseconds timeout)
void	removeConnection (ManagedConnection *connection)
void	initiateGracefulShutdown (std::chrono::milliseconds idleGrace)
void	drainConnections (double pct, std::chrono::milliseconds idleGrace)
void	dropAllConnections ()
void	dropConnections (double pct)
size_t	getNumConnections () const
template<typename F >
void	iterateConns (F func)
std::chrono::milliseconds	getDefaultTimeout () const
void	setLoweredIdleTimeout (std::chrono::milliseconds timeout)
size_t	dropIdleConnections (size_t num)
void	onActivated (ManagedConnection &conn) override
void	onDeactivated (ManagedConnection &conn) override
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	makeUnique (Args &&...args)

Private Types
enum	ShutdownState : uint8_t {   ShutdownState::NONE = 0, ShutdownState::NOTIFY_PENDING_SHUTDOWN = 1, ShutdownState::NOTIFY_PENDING_SHUTDOWN_COMPLETE = 2, ShutdownState::CLOSE_WHEN_IDLE = 3,   ShutdownState::CLOSE_WHEN_IDLE_COMPLETE = 4 }

Private Member Functions
	~ConnectionManager () override=default
	ConnectionManager (const ConnectionManager &)=delete
ConnectionManager &	operator= (ConnectionManager &)=delete
void	drainAllConnections ()
void	stopDrainingForShutdown ()
void	idleGracefulTimeoutExpired ()
Private Member Functions inherited from wangle::ManagedConnection::Callback
virtual	~Callback ()=default

Private Attributes
folly::CountedIntrusiveList< ManagedConnection,&ManagedConnection::listHook_ >	conns_
Callback *	callback_
folly::EventBase *	eventBase_
ConnectionIterator	drainIterator_
ConnectionIterator	idleIterator_
DrainHelper	drainHelper_
bool	notifyPendingShutdown_ {true}
std::chrono::milliseconds	timeout_
std::chrono::milliseconds	idleConnEarlyDropThreshold_

Additional Inherited Members
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

A ConnectionManager keeps track of ManagedConnections.

Definition at line 34 of file ConnectionManager.h.

Member Typedef Documentation

typedef folly::CountedIntrusiveList< ManagedConnection, &ManagedConnection::listHook_>::iterator wangle::ConnectionManager::ConnectionIterator

Definition at line 66 of file ConnectionManager.h.

typedef std::unique_ptr<ConnectionManager, Destructor> wangle::ConnectionManager::UniquePtr

Definition at line 63 of file ConnectionManager.h.

Member Enumeration Documentation

enum wangle::ConnectionManager::ShutdownState : uint8_t

strongprivate

Enumerator
NONE
NOTIFY_PENDING_SHUTDOWN
NOTIFY_PENDING_SHUTDOWN_COMPLETE
CLOSE_WHEN_IDLE
CLOSE_WHEN_IDLE_COMPLETE

Definition at line 174 of file ConnectionManager.h.

                            : uint8_t {
     NONE = 0,
     // All ManagedConnections receive notifyPendingShutdown
     NOTIFY_PENDING_SHUTDOWN = 1,
     // All ManagedConnections have received notifyPendingShutdown
     NOTIFY_PENDING_SHUTDOWN_COMPLETE = 2,
     // All ManagedConnections receive closeWhenIdle
     CLOSE_WHEN_IDLE = 3,
     // All ManagedConnections have received closeWhenIdle
     CLOSE_WHEN_IDLE_COMPLETE = 4,
   };

Constructor & Destructor Documentation

wangle::ConnectionManager::ConnectionManager	(	folly::EventBase *	eventBase,
		std::chrono::milliseconds	timeout,
		Callback *	callback = nullptr
	)

Constructor not to be used by itself.

Referenced by makeUnique().

wangle::ConnectionManager::~ConnectionManager ( )

overrideprivatedefault

wangle::ConnectionManager::ConnectionManager ( const ConnectionManager &  )

privatedelete

Member Function Documentation

void wangle::ConnectionManager::addConnection	(	ManagedConnection *	connection,
		bool	timeout = false
	)

Add a connection to the set of connections managed by this ConnectionManager.

Parameters

connection	The connection to add.
timeout	Whether to immediately register this connection for an idle timeout callback.

Definition at line 40 of file ConnectionManager.cpp.

References callback_, wangle::ManagedConnection::fireCloseWhenIdle(), wangle::ManagedConnection::fireNotifyPendingShutdown(), wangle::ManagedConnection::getConnectionManager(), wangle::ManagedConnection::listHook_, removeConnection(), and wangle::ManagedConnection::setConnectionManager().

Referenced by makeUnique().

                  {
  CHECK_NOTNULL(connection);
  ConnectionManager* oldMgr = connection->getConnectionManager();
  if (oldMgr != this) {
    if (oldMgr) {
      // 'connection' was being previously managed in a different thread.
      // We must remove it from that manager before adding it to this one.
      oldMgr->removeConnection(connection);
    }

    // put the connection into busy part first.  This should not matter at all
    // because the last callback for an idle connection must be onDeactivated(),
    // so the connection must be moved to idle part then.
    conns_.push_front(*connection);

    connection->setConnectionManager(this);
    if (callback_) {
      callback_->onConnectionAdded(connection);
    }
  }
  if (timeout) {
    scheduleTimeout(connection, timeout_);
  }

  if (drainHelper_.getShutdownState() >=
      ShutdownState::NOTIFY_PENDING_SHUTDOWN &&
      notifyPendingShutdown_) {
    connection->fireNotifyPendingShutdown();
  }

  if (drainHelper_.getShutdownState() >= ShutdownState::CLOSE_WHEN_IDLE) {
    // closeWhenIdle can delete the connection (it was just created, so it's
    // probably idle).  Delay the closeWhenIdle call until the end of the loop
    // where it will be safer to terminate the conn.
    // Hold a DestructorGuard to the end of the loop for this
    auto cmDg = new DestructorGuard(this);
    auto connDg = new DestructorGuard(connection);
    eventBase_->runInLoop([connection, this, cmDg, connDg] {
        if (connection->listHook_.is_linked()) {
          auto it = conns_.iterator_to(*connection);
          DCHECK(it != conns_.end());
          connection->fireCloseWhenIdle(!notifyPendingShutdown_);
        }
        delete connDg;
        delete cmDg;
      });
  }
}

void wangle::ConnectionManager::drainAllConnections ( )

private

Destroy all connections managed by this ConnectionManager that are currently idle, as determined by a call to each ManagedConnection's isBusy() method.

void wangle::ConnectionManager::drainConnections	(	double	pct,
		std::chrono::milliseconds	idleGrace
	)

Gracefully shutdown certain percentage of persistent client connections and leave the rest intact.

Definition at line 141 of file ConnectionManager.cpp.

References wangle::NONE.

Referenced by makeUnique(), wangle::ConnectionManager::DrainHelper::runLoopCallback(), and wangle::ConnectionManager::DrainHelper::timeoutExpired().

                                                                          {
  if (drainHelper_.getShutdownState() != ShutdownState::NONE) {
    VLOG(3) << "Ignoring partial drain with full drain in progress";
    return;
  }
  drainHelper_.startDrainPartial(pct, idleGrace);
}

void wangle::ConnectionManager::dropAllConnections

(

)

Destroy all connections Managed by this ConnectionManager, even the ones that are busy.

Definition at line 255 of file ConnectionManager.cpp.

References callback_, folly::HHWheelTimer::Callback::cancelTimeout(), wangle::ManagedConnection::dropConnection(), wangle::ManagedConnection::dumpConnectionState(), g(), i, and wangle::ManagedConnection::setConnectionManager().

Referenced by makeUnique().

                                      {
  DestructorGuard g(this);

  // Signal the drain helper in case that has not happened before.
  stopDrainingForShutdown();

  // Iterate through our connection list, and drop each connection.
  VLOG_IF(4, conns_.empty()) << "no connections to drop";
  VLOG_IF(2, !conns_.empty()) << "connections to drop: " << conns_.size();

  unsigned i = 0;
  while (!conns_.empty()) {
    ManagedConnection& conn = conns_.front();
    conns_.pop_front();
    conn.cancelTimeout();
    conn.setConnectionManager(nullptr);
    // For debugging purposes, dump information about the first few
    // connections.
    static const unsigned MAX_CONNS_TO_DUMP = 2;
    if (++i <= MAX_CONNS_TO_DUMP) {
      conn.dumpConnectionState(3);
    }
    conn.dropConnection();
  }
  drainIterator_ = conns_.end();
  idleIterator_ = conns_.end();
  drainHelper_.cancelLoopCallback();

  if (callback_) {
    callback_->onEmpty(*this);
  }
}

void wangle::ConnectionManager::dropConnections

(

double

pct

)

Force-stop "pct" (0.0 to 1.0) of remaining client connections, regardless of whether they are busy or idle.

Definition at line 289 of file ConnectionManager.cpp.

References wangle::ManagedConnection::dropConnection(), g(), and i.

Referenced by makeUnique().

                                             {
  DestructorGuard g(this);

  // Signal the drain helper in case that has not happened before.
  stopDrainingForShutdown();

  const size_t N = conns_.size();
  const size_t numToDrop = std::max<size_t>(0, std::min<size_t>(N, N * pct));
  for (size_t i = 0; i < numToDrop && !conns_.empty(); i++) {
    ManagedConnection& conn = conns_.front();
    removeConnection(&conn);
    conn.dropConnection();
  }
}

size_t wangle::ConnectionManager::dropIdleConnections

(

size_t

num

)

try to drop num idle connections to release system resources. Return the actual number of dropped idle connections

Definition at line 333 of file ConnectionManager.cpp.

References count, and wangle::ManagedConnection::dropConnection().

Referenced by setLoweredIdleTimeout().

                                                 {
  VLOG(4) << "attempt to drop " << num << " idle connections";
  if (idleConnEarlyDropThreshold_ >= timeout_) {
    return 0;
  }

  size_t count = 0;
  while(count < num) {
    auto it = idleIterator_;
    if (it == conns_.end()) {
      return count; // no more idle session
    }
    auto idleTime = it->getIdleTime();
    if (idleTime == std::chrono::milliseconds(0) ||
          idleTime <= idleConnEarlyDropThreshold_) {
      VLOG(4) << "conn's idletime: " << idleTime.count()
              << ", earlyDropThreshold: " << idleConnEarlyDropThreshold_.count()
              << ", attempt to drop " << count << "/" << num;
      return count; // idleTime cannot be further reduced
    }
    ManagedConnection& conn = *it;
    idleIterator_++;
    conn.dropConnection();
    count++;
  }

  return count;
}

std::chrono::milliseconds wangle::ConnectionManager::getDefaultTimeout ( ) const

inline

Definition at line 149 of file ConnectionManager.h.

References timeout_.

Referenced by wangle::ManagedConnection::resetTimeout().

                                                  {
    return timeout_;
  }

size_t wangle::ConnectionManager::getNumConnections ( ) const

inline

Definition at line 138 of file ConnectionManager.h.

References conns_.

{ return conns_.size(); }

void wangle::ConnectionManager::idleGracefulTimeoutExpired ( )

private

Referenced by wangle::ConnectionManager::DrainHelper::timeoutExpired().

void wangle::ConnectionManager::initiateGracefulShutdown

(

std::chrono::milliseconds

idleGrace

)

Definition at line 131 of file ConnectionManager.cpp.

References wangle::NONE.

Referenced by makeUnique().

                                   {
  VLOG(3) << this << " initiateGracefulShutdown with nconns=" << conns_.size();
  if (drainHelper_.getShutdownState() != ShutdownState::NONE) {
    VLOG(3) << "Ignoring redundant call to initiateGracefulShutdown";
    return;
  }
  drainHelper_.startDrainAll(idleGrace);
}

template<typename F >

void wangle::ConnectionManager::iterateConns ( F  func )

inline

Definition at line 141 of file ConnectionManager.h.

References conns_.

                            {
    auto it = conns_.begin();
    while ( it != conns_.end()) {
      func(&(*it));
      it++;
    }
  }

template<typename... Args>

static UniquePtr wangle::ConnectionManager::makeUnique ( Args &&...  args )

inlinestatic

Returns a new instance of ConnectionManager wrapped in a unique_ptr

Definition at line 71 of file ConnectionManager.h.

References addConnection(), ConnectionManager(), drainConnections(), dropAllConnections(), dropConnections(), initiateGracefulShutdown(), removeConnection(), scheduleTimeout(), and folly::detail::timeout.

Referenced by wangle::Acceptor::initDownstreamConnectionManager(), and TEST_F().

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

void wangle::ConnectionManager::onActivated ( ManagedConnection &  conn )

overridevirtual

ManagedConnection::Callbacks

Implements wangle::ManagedConnection::Callback.

Definition at line 305 of file ConnectionManager.cpp.

Referenced by proxygen::HTTPSession::createTransaction(), and setLoweredIdleTimeout().

                                                      {
  auto it = conns_.iterator_to(conn);
  if (it == idleIterator_) {
    idleIterator_++;
  }
  conns_.erase(it);
  conns_.push_front(conn);
}

void wangle::ConnectionManager::onDeactivated ( ManagedConnection &  conn )

overridevirtual

Implements wangle::ManagedConnection::Callback.

Definition at line 315 of file ConnectionManager.cpp.

Referenced by proxygen::HTTPSession::detach(), and setLoweredIdleTimeout().

                                                        {
  auto it = conns_.iterator_to(conn);
  bool moveDrainIter = false;
  if (it == drainIterator_) {
    drainIterator_++;
    moveDrainIter = true;
  }
  conns_.erase(it);
  conns_.push_back(conn);
  if (idleIterator_ == conns_.end()) {
    idleIterator_--;
  }
  if (moveDrainIter && drainIterator_ == conns_.end()) {
    drainIterator_--;
  }
}

ConnectionManager& wangle::ConnectionManager::operator= ( ConnectionManager &  )

privatedelete

void wangle::ConnectionManager::removeConnection

(

ManagedConnection *

connection

)

Remove a connection from this ConnectionManager and, if applicable, cancel the pending timeout callback that the ConnectionManager has scheduled for the connection.

Note

This method does NOT destroy the connection.

Definition at line 105 of file ConnectionManager.cpp.

References callback_, folly::HHWheelTimer::Callback::cancelTimeout(), wangle::ManagedConnection::getConnectionManager(), wangle::SimpleConnectionCounter::getNumConnections(), and wangle::ManagedConnection::setConnectionManager().

Referenced by addConnection(), makeUnique(), and wangle::ManagedConnection::~ManagedConnection().

                                                                 {
  if (connection->getConnectionManager() == this) {
    connection->cancelTimeout();
    connection->setConnectionManager(nullptr);

    // Un-link the connection from our list, being careful to keep the iterator
    // that we're using for idle shedding valid
    auto it = conns_.iterator_to(*connection);
    if (it == drainIterator_) {
      ++drainIterator_;
    }
    if (it == idleIterator_) {
      ++idleIterator_;
    }
    conns_.erase(it);

    if (callback_) {
      callback_->onConnectionRemoved(connection);
      if (getNumConnections() == 0) {
        callback_->onEmpty(*this);
      }
    }
  }
}

void wangle::ConnectionManager::scheduleTimeout	(	ManagedConnection *const	connection,
		std::chrono::milliseconds	timeout
	)

Schedule a timeout callback for a connection.

Definition at line 91 of file ConnectionManager.cpp.

Referenced by makeUnique(), wangle::ManagedConnection::resetTimeoutTo(), wangle::ManagedConnection::scheduleTimeout(), and wangle::AcceptorHandshakeManager::startHandshakeTimeout().

                                   {
  if (timeout > std::chrono::milliseconds(0)) {
    eventBase_->timer().scheduleTimeout(connection, timeout);
  }
}

void wangle::ConnectionManager::scheduleTimeout	(	folly::HHWheelTimer::Callback *	callback,
		std::chrono::milliseconds	timeout
	)

Definition at line 98 of file ConnectionManager.cpp.

                                 {
  eventBase_->timer().scheduleTimeout(callback, timeout);
}

void wangle::ConnectionManager::setLoweredIdleTimeout ( std::chrono::milliseconds  timeout )

inline

Definition at line 153 of file ConnectionManager.h.

References dropIdleConnections(), idleConnEarlyDropThreshold_, onActivated(), onDeactivated(), and timeout_.

                                                            {
    CHECK(timeout >= std::chrono::milliseconds(0));
    CHECK(timeout <= timeout_);
    idleConnEarlyDropThreshold_ = timeout;
  }

void wangle::ConnectionManager::stopDrainingForShutdown ( )

private

Signal the drain helper that we are about to start dropping connections.

Definition at line 249 of file ConnectionManager.cpp.

                                                {
  drainHelper_.setShutdownState(ShutdownState::CLOSE_WHEN_IDLE_COMPLETE);
  drainHelper_.cancelTimeout();
}

Member Data Documentation

Callback* wangle::ConnectionManager::callback_

private

Optional callback to notify of state changes

Definition at line 272 of file ConnectionManager.h.

folly::CountedIntrusiveList< ManagedConnection,&ManagedConnection::listHook_> wangle::ConnectionManager::conns_

private

All the managed connections. idleIterator_ seperates them into two parts: idle and busy ones. [conns_.begin(), idleIterator_) are the busy ones, while [idleIterator_, conns_.end()) are the idle one. Moreover, the idle ones are organized in the decreasing idle time order.

Definition at line 269 of file ConnectionManager.h.

Referenced by getNumConnections(), and iterateConns().

DrainHelper wangle::ConnectionManager::drainHelper_

private

Definition at line 280 of file ConnectionManager.h.

ConnectionIterator wangle::ConnectionManager::drainIterator_

private

Iterator to the next connection to shed; used by drainAllConnections()

Definition at line 278 of file ConnectionManager.h.

folly::EventBase* wangle::ConnectionManager::eventBase_

private

Event base in which we run

Definition at line 275 of file ConnectionManager.h.

std::chrono::milliseconds wangle::ConnectionManager::idleConnEarlyDropThreshold_

private

The idle connections can be closed earlier that their idle timeout when any system resource limit is reached. This feature can be considerred as a pre load shedding stage for the system, and can be easily disabled by setting idleConnEarlyDropThreshold_ to defaultIdleTimeout_. Also, idleConnEarlyDropThreshold_ can be used to bottom the idle timeout. That is, connection manager will not early drop the idle connections whose idle time is less than idleConnEarlyDropThreshold_.

Definition at line 298 of file ConnectionManager.h.

Referenced by setLoweredIdleTimeout().

ConnectionIterator wangle::ConnectionManager::idleIterator_

private

Definition at line 279 of file ConnectionManager.h.

bool wangle::ConnectionManager::notifyPendingShutdown_ {true}

private

Definition at line 281 of file ConnectionManager.h.

std::chrono::milliseconds wangle::ConnectionManager::timeout_

private

the default idle timeout for downstream sessions when no system resource limit is reached

Definition at line 287 of file ConnectionManager.h.

Referenced by getDefaultTimeout(), and setLoweredIdleTimeout().

---

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

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