wangle::ShardedLocalSSLSessionCache Class Reference

#include <SSLSessionCacheManager.h>

Inheritance diagram for wangle::ShardedLocalSSLSessionCache:

Public Member Functions
	ShardedLocalSSLSessionCache (uint32_t n_buckets, uint32_t maxCacheSize, uint32_t cacheCullSize)
SSL_SESSION *	lookupSession (const std::string &sessionId)
void	storeSession (const std::string &sessionId, SSL_SESSION *session, SSLStats *stats)
void	removeSession (const std::string &sessionId)
size_t	hash (const std::string &key)

Public Attributes
std::vector< std::unique_ptr< LocalSSLSessionCache > >	caches_

Detailed Description

A sharded LRU for SSL sessions. The sharding is inteneded to reduce contention for the LRU locks. Assuming uniform distribution, two workers will contend for the same lock with probability 1 / n_buckets^2.

Definition at line 63 of file SSLSessionCacheManager.h.

Constructor & Destructor Documentation

wangle::ShardedLocalSSLSessionCache::ShardedLocalSSLSessionCache	(	uint32_t	n_buckets,
		uint32_t	maxCacheSize,
		uint32_t	cacheCullSize
	)

Definition at line 73 of file SSLSessionCacheManager.cpp.

References i, wangle::LocalSSLSessionCache::LocalSSLSessionCache(), and uint32_t.

                            {
  CHECK(n_buckets > 0);
  maxCacheSize = (uint32_t)(((double)maxCacheSize) / n_buckets);
  cacheCullSize = (uint32_t)(((double)cacheCullSize) / n_buckets);
  if (maxCacheSize == 0) {
    maxCacheSize = 1;
  }
  if (cacheCullSize == 0) {
    cacheCullSize = 1;
  }
  for (uint32_t i = 0; i < n_buckets; i++) {
    caches_.push_back(std::unique_ptr<LocalSSLSessionCache>(
        new LocalSSLSessionCache(maxCacheSize, cacheCullSize)));
  }
}

Member Function Documentation

size_t wangle::ShardedLocalSSLSessionCache::hash ( const std::string &  key )

inline

Definition at line 75 of file SSLSessionCacheManager.h.

Referenced by TEST().

                                    {
    return folly::Hash()(key) % caches_.size();
  }

SSL_SESSION * wangle::ShardedLocalSSLSessionCache::lookupSession

(

const std::string &

sessionId

)

Definition at line 92 of file SSLSessionCacheManager.cpp.

References folly::EvictingCacheMap< TKey, TValue, THash, TKeyEqual >::end(), g(), wangle::LocalSSLSessionCache::lock, and wangle::LocalSSLSessionCache::sessionCache.

                                {
  size_t bucket = hash(sessionId);
  SSL_SESSION* session = nullptr;
  std::lock_guard<std::mutex> g(caches_[bucket]->lock);

  auto itr = caches_[bucket]->sessionCache.find(sessionId);
  if (itr != caches_[bucket]->sessionCache.end()) {
    session = itr->second;
  }

  if (session) {
    SSL_SESSION_up_ref(session);
  }
  return session;
}

void wangle::ShardedLocalSSLSessionCache::removeSession

(

const std::string &

sessionId

)

Definition at line 134 of file SSLSessionCacheManager.cpp.

References g(), and wangle::LocalSSLSessionCache::lock.

                                                                          {
  size_t bucket = hash(sessionId);
  std::lock_guard<std::mutex> g(caches_[bucket]->lock);
  caches_[bucket]->sessionCache.erase(sessionId);
}

void wangle::ShardedLocalSSLSessionCache::storeSession	(	const std::string &	sessionId,
		SSL_SESSION *	session,
		SSLStats *	stats
	)

Definition at line 109 of file SSLSessionCacheManager.cpp.

References folly::EvictingCacheMap< TKey, TValue, THash, TKeyEqual >::end(), g(), wangle::LocalSSLSessionCache::lock, wangle::SSLStats::recordSSLSessionFree(), wangle::LocalSSLSessionCache::removedSessions_, and wangle::LocalSSLSessionCache::sessionCache.

                     {
  size_t bucket = hash(sessionId);
  SSL_SESSION* oldSession = nullptr;
  std::lock_guard<std::mutex> g(caches_[bucket]->lock);

  auto itr = caches_[bucket]->sessionCache.find(sessionId);
  if (itr != caches_[bucket]->sessionCache.end()) {
    oldSession = itr->second;
  }

  if (oldSession) {
    // LRUCacheMap doesn't free on overwrite, so 2x the work for us
    // This can happen in race conditions
    SSL_SESSION_free(oldSession);
  }
  caches_[bucket]->removedSessions_ = 0;
  caches_[bucket]->sessionCache.set(sessionId, session, true);
  if (stats) {
    stats->recordSSLSessionFree(caches_[bucket]->removedSessions_);
  }
}

Member Data Documentation

std::vector< std::unique_ptr<LocalSSLSessionCache> > wangle::ShardedLocalSSLSessionCache::caches_

Definition at line 79 of file SSLSessionCacheManager.h.

---

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

• proxygen/wangle/wangle/ssl/SSLSessionCacheManager.h
• proxygen/wangle/wangle/ssl/SSLSessionCacheManager.cpp