wangle Namespace Reference

Namespaces
	client
	detail
	test

Classes
class	Acceptor
class	AcceptorException
class	AcceptorFactory
class	AcceptorHandshakeHelper
class	AcceptorHandshakeManager
class	AcceptorTest
class	AcceptPipelineFactory
class	AcceptRoutingHandler
class	AcceptRoutingPipelineFactory
class	AppendFilter
class	AsyncServerSocketFactory
class	AsyncSocketHandler
class	AsyncUDPServerSocketFactory
class	BaseClientBootstrap
class	BaseClientBootstrapFactory
class	BaseWithOptional
class	BaseWithoutOptional
class	BroadcastHandler
class	BroadcastPipelineFactory
class	BroadcastPool
class	ByteToMessageDecoder
struct	CacheLockGuard
struct	CacheLockGuard< folly::SharedMutex >
struct	CacheLockGuard< std::mutex >
class	CachePersistence
class	ChangeTypeFilter
class	ClientBootstrap
class	ClientBootstrapFactory
class	ClientDispatcherBase
class	ClientHelloExtStats
class	ClientPipelineFactory
class	ClientServiceFactory
class	CloseOnReleaseFilter
class	ConnectionCountFilter
class	ConnectionManager
struct	ConnInfo
class	ConstFactory
class	ContextImpl
class	ContextImplBase
struct	ContextType
class	DefaultAcceptPipelineFactory
class	DefaultToFizzPeekingCallback
class	DefaultToSSLPeekingCallback
struct	dn_char_traits
class	EchoIntService
class	EchoService
class	EvbHandshakeHelper
class	EventBaseHandler
class	ExecutorFilter
class	ExpiringFilter
class	FactoryToService
class	FilePersistenceLayer
class	FilePersistentCache
class	FilePoller
class	FixedLengthFrameDecoder
class	FizzAcceptorHandshakeHelper
struct	FizzClientConfig
struct	FizzConfig
class	FizzConfigUtil
class	FizzHandshakeException
struct	FunctionObserver
class	Handler
class	HandlerAdapter
class	HandlerBase
class	HandlerContext
struct	HTTPHeaderSize
class	IConnectionCounter
class	InboundContextImpl
class	InboundHandler
class	InboundHandlerContext
class	InboundLink
class	IntToStringFilter
class	LengthFieldBasedFrameDecoder
class	LengthFieldPrepender
class	LineBasedFrameDecoder
class	LoadShedConfiguration
class	LocalSSLSessionCache
class	LRUInMemoryCache
class	LRUPersistentCache
class	ManagedConnection
class	MessageToByteEncoder
class	MockAcceptPipelineFactory
class	MockAcceptRoutingHandler
class	MockBroadcastHandler
class	MockBroadcastPipelineFactory
class	MockBroadcastPool
class	MockBytesToBytesHandler
class	MockByteToMessageDecoder
class	MockDownstreamPipelineFactory
class	MockHandler
class	MockMessageToByteEncoder
class	MockObservingHandler
class	MockObservingPipelineFactory
class	MockPersistentCache
class	MockPipelineManager
class	MockRoutingDataHandler
class	MockRoutingDataHandlerFactory
class	MockServerPool
class	MockSSLSessionCallbacks
class	MockSubscriber
class	MockTimeUtil
class	MultiFilePoller
class	MultiplexServerDispatcher
class	NetworkAddress
class	Observable
struct	Observer
class	ObservingHandler
class	ObservingPipelineFactory
class	OutboundContextImpl
class	OutboundHandler
class	OutboundHandlerContext
class	OutboundLink
class	OutputBufferingHandler
class	PeekingAcceptorHandshakeHelper
class	PeekingAcceptorHandshakeManager
struct	PendingLookup
class	PersistentCache
class	Pipeline
class	PipelineBase
class	PipelineContext
class	PipelinedClientDispatcher
class	PipelinedServerDispatcher
class	PipelineFactory
class	PipelineManager
struct	ProtocolInfo
class	RoutingDataHandler
class	RoutingDataHandlerFactory
class	RoutingDataPipelineFactory
class	SecurityProtocolContextManager
class	SerialClientDispatcher
class	SerialServerDispatcher
class	ServerAcceptor
class	ServerAcceptorFactory
class	ServerBootstrap
class	ServerPipelineFactory
class	ServerPool
struct	ServerSocketConfig
class	ServerSocketFactory
class	ServerSSLContext
class	ServerWorkerPool
class	Service
class	ServiceFactory
class	ServiceFactoryFilter
class	ServiceFilter
class	SessionDestructor
class	ShardedLocalSSLSessionCache
class	SimpleConnectionCounter
class	SimpleConnectionCounterForTest
class	SimpleDecode
class	SocketPeeker
class	SSLAcceptorHandshakeHelper
struct	SSLCacheOptions
class	SSLCacheProvider
struct	SSLContextConfig
struct	SSLContextKey
struct	SSLContextKeyHash
class	SSLContextManager
class	SSLContextManagerForTest
class	SSLException
struct	SSLSessionCacheData
class	SSLSessionCacheManager
class	SSLSessionCallbacks
class	SSLSessionEstablishedCallback
class	SSLSessionPersistentCache
class	SSLSessionPersistentCacheBase
class	SSLSessionPersistentCacheTest
class	SSLStats
class	SSLUtil
class	StaticPipeline
class	StaticPipeline< R, W >
class	StaticPipeline< R, W, Handler, Handlers... >
class	StringCodec
struct	Subject
class	Subscriber
class	Subscription
class	TestableAcceptor
class	ThreadSafeSSLSessionCache
class	TimekeeperTester
class	TLSCredProcessor
class	TLSPlaintextPeekingCallback
class	TLSTicketKeyManager
struct	TLSTicketKeySeeds
struct	TokenBindingConfig
struct	TransportInfo
class	UnencryptedAcceptorHandshakeHelper

Typedefs
using	PeekingCallbackPtr = PeekingAcceptorHandshakeHelper::PeekCallback *
typedef std::basic_string< char, dn_char_traits >	DNString
using	SSLSessionEstablishedCallbackUniquePtr = std::unique_ptr< SSLSessionEstablishedCallback >
template<typename T >
using	ObservingPipeline = Pipeline< folly::IOBufQueue &, T >
typedef HandlerAdapter< folly::IOBufQueue &, std::unique_ptr< folly::IOBuf > >	BytesToBytesHandler
typedef InboundHandler< folly::IOBufQueue &, std::unique_ptr< folly::IOBuf > >	InboundBytesToBytesHandler
typedef OutboundHandler< std::unique_ptr< folly::IOBuf > >	OutboundBytesToBytesHandler
using	DefaultPipeline = Pipeline< folly::IOBufQueue &, std::unique_ptr< folly::IOBuf >>
typedef boost::variant< folly::IOBuf *, folly::AsyncTransportWrapper *, ConnInfo &, ConnEvent, std::tuple< folly::IOBuf *, std::shared_ptr< folly::AsyncUDPSocket >, folly::SocketAddress > >	AcceptPipelineType
typedef Pipeline< AcceptPipelineType >	AcceptPipeline
template<class R , class W = R>
using	MockHandlerAdapter = MockHandler< R, R, W, W >
using	CacheDataVersion = uint64_t
typedef std::unique_ptr< SSL_SESSION, SessionDestructor >	SSLSessionPtr
typedef ByteToMessageDecoder< std::unique_ptr< folly::IOBuf > >	ByteToByteDecoder
typedef folly::exception_wrapper	Error
typedef std::shared_ptr< folly::Executor >	SchedulerPtr
template<class T >
using	ObservablePtr = std::shared_ptr< Observable< T >>
template<class T >
using	ObserverPtr = std::shared_ptr< Observer< T >>
template<class T >
using	SubjectPtr = std::shared_ptr< Subject< T >>
typedef Pipeline< IOBufQueue &, std::string >	ServicePipeline
typedef folly::EvictingCacheMap< std::string, SSL_SESSION * >	SSLSessionCacheMap
typedef std::pair< folly::AsyncSSLSocket *, std::unique_ptr< folly::DelayedDestruction::DestructorGuard > >	AttachedLookup
typedef std::map< std::string, PendingLookup >	PendingLookupMap

Enumerations
enum	SecureTransportType { SecureTransportType::NONE, SecureTransportType::TLS, SecureTransportType::ZERO }
enum	CertCrypto { CertCrypto::BEST_AVAILABLE, CertCrypto::SHA1_SIGNATURE }
enum	HandlerDir { HandlerDir::IN, HandlerDir::OUT, HandlerDir::BOTH }
enum	ConnEvent { ConnEvent::CONN_ADDED, ConnEvent::CONN_REMOVED }
enum	SSLResumeEnum : uint8_t { SSLResumeEnum::HANDSHAKE = 0, SSLResumeEnum::RESUME_SESSION_ID = 1, SSLResumeEnum::RESUME_TICKET = 3, SSLResumeEnum::NA = 2 }
enum	SSLErrorEnum { SSLErrorEnum::NO_ERROR, SSLErrorEnum::TIMEOUT, SSLErrorEnum::DROPPED }

Functions
std::ostream &	operator<< (std::ostream &os, const ManagedConnection &conn)
std::string	getSecureTransportName (const SecureTransportType &type)
AsyncSocket::OptionMap	filterIPSocketOptions (const AsyncSocket::OptionMap &allOptions, const int addrFamily)
	TEST_F (AcceptorTest, TestCanAcceptWithNoConnectionCounter)
	TEST_F (AcceptorTest, TestCanAcceptWithMaxConnectionsZero)
	TEST_F (AcceptorTest, TestCanAcceptWithCurrentConnsLessThanMax)
	TEST_F (AcceptorTest, TestCanAcceptWithCurrentConnsGreaterThanMax)
	TEST_F (AcceptorTest, TestCanAcceptWhiteListedAddress)
	TEST_F (AcceptorTest, TestCanAcceptWithNoLoadShed)
	TEST_F (AcceptorTest, TestCanAcceptWithMaxActiveConnectionsNotSet)
	TEST_F (AcceptorTest, TestCanAcceptWithActiveConnectionsBreachingThreshold)
	TEST_F (AcceptorTest, TestCanAcceptWithTotalConnectionsBreachingThreshold)
	TEST_F (AcceptorTest, TestCanAcceptWithBothConnectionCountsBreachingThresholds)
std::string	getPersistentCacheFilename ()
template<typename K , typename V , typename MutexT = std::mutex>
void	testSimplePutGet (const std::vector< K > &keys, const std::vector< V > &values)
bool	setSessionServiceIdentity (SSL_SESSION *session, const std::string &str)
folly::Optional< std::string >	getSessionServiceIdentity (SSL_SESSION *session)
folly::Optional< SSLSessionCacheData >	getCacheDataForSession (SSL_SESSION *sess)
SSL_SESSION *	getSessionFromCacheData (const SSLSessionCacheData &data)
SSL_SESSION *	cloneSSLSession (SSL_SESSION *toClone)
	TEST_F (SSLSessionPersistentCacheTest, Basic)
	TEST_F (SSLSessionPersistentCacheTest, BadSession)
	TEST_F (SSLSessionPersistentCacheTest, Overwrite)
	TEST_F (SSLSessionPersistentCacheTest, SessionTicketTimeout)
std::vector< std::pair< SSL_SESSION *, size_t > >	getSessions ()
std::pair< SSL_SESSION *, size_t >	getSessionWithTicket ()
SSLSessionPtr	createPersistentTestSession (std::pair< SSL_SESSION *, size_t > session)
std::string	getSessionData (SSL_SESSION *s, size_t expectedLength)
bool	isSameSession (std::pair< SSL_SESSION *, size_t > lhs, std::pair< SSL_SESSION *, size_t > rhs)
	TEST (Wangle, ClientServerTest)
	TEST (Wangle, FilterTest)
	TEST (Wangle, ComplexFilterTest)
	TEST (Wangle, SuperComplexFilterTest)
	TEST (Wangle, ServiceFactoryFilter)
	TEST (Wangle, FactoryToService)
	TEST (ServiceFilter, ExpiringMax)
	TEST (ServiceFilter, ExpiringIdle)
	TEST (ServiceFilter, NoIdleDuringRequests)
	TEST (SSLContextManagerTest, Test1)
	TEST (SSLContextManagerTest, DISABLED_TestSessionContextIfSupplied)
	TEST (SSLContextManagerTest, DISABLED_TestSessionContextIfSessionCacheAbsent)

Variables
static const std::string	empty_string
static const std::string	empty_string
const size_t	kNumSessions = 3
const size_t	kSessionDataLen = 1060
const unsigned char	kSessionData [kNumSessions][kSessionDataLen]
const unsigned char	kSessionDataWithTicket []

Detailed Description

SSLContextConfig helps to describe the configs/options for a SSL_CTX. For example:

1. Filename of X509, private key and its password.
2. ciphers list
3. NPN list
4. Is session cache enabled?
5. Is it the default X509 in SNI operation?
6. .... and a few more

SSLContextManager helps to create and manage all SSL_CTX, SSLSessionCacheManager and TLSTicketManager for a listening VIP:PORT. (Note, in SNI, a listening VIP:PORT can have >1 SSL_CTX(s)).

Other responsibilities:

1. It also handles the SSL_CTX selection after getting the tlsext_hostname in the client hello message.

Usage:

1. Each listening VIP:PORT serving SSL should have one SSLContextManager. It maps to Acceptor in the wangle vocabulary.
2. Create a SSLContextConfig object (e.g. by parsing the JSON config).
3. Call SSLContextManager::addSSLContextConfig() which will then create and configure the SSL_CTX

Note: Each Acceptor, with SSL support, should have one SSLContextManager to manage all SSL_CTX for the VIP:PORT.

Typedef Documentation

typedef Pipeline<AcceptPipelineType> wangle::AcceptPipeline

Definition at line 278 of file Pipeline.h.

typedef boost::variant<folly::IOBuf*, folly::AsyncTransportWrapper*, ConnInfo&, ConnEvent, std::tuple<folly::IOBuf*, std::shared_ptr<folly::AsyncUDPSocket>, folly::SocketAddress> > wangle::AcceptPipelineType

Definition at line 277 of file Pipeline.h.

typedef std::pair<folly::AsyncSSLSocket *, std::unique_ptr<folly::DelayedDestruction::DestructorGuard> > wangle::AttachedLookup

Definition at line 85 of file SSLSessionCacheManager.h.

typedef HandlerAdapter<folly::IOBufQueue&, std::unique_ptr<folly::IOBuf> > wangle::BytesToBytesHandler

Definition at line 173 of file Handler.h.

typedef ByteToMessageDecoder<std::unique_ptr<folly::IOBuf> > wangle::ByteToByteDecoder

Definition at line 82 of file ByteToMessageDecoder.h.

using wangle::CacheDataVersion = typedef uint64_t

A counter that represents a "version" of the data. This is used to determine if two components have been synced to the same version. A valid version is 1 or higher. A version of 0 implies no version.

Definition at line 40 of file PersistentCacheCommon.h.

using wangle::DefaultPipeline = typedef Pipeline<folly::IOBufQueue&, std::unique_ptr<folly::IOBuf>>

Definition at line 241 of file Pipeline.h.

typedef std::basic_string<char, dn_char_traits> wangle::DNString

Definition at line 70 of file SSLContextSelectionMisc.h.

typedef folly::exception_wrapper wangle::Error

Definition at line 24 of file types.h.

typedef InboundHandler<folly::IOBufQueue&, std::unique_ptr<folly::IOBuf> > wangle::InboundBytesToBytesHandler

Definition at line 176 of file Handler.h.

template<class R , class W = R>

using wangle::MockHandlerAdapter = typedef MockHandler<R, R, W, W>

Definition at line 71 of file MockHandler.h.

template<class T >

using wangle::ObservablePtr = typedef std::shared_ptr<Observable<T>>

Definition at line 33 of file types.h.

template<class T >

using wangle::ObserverPtr = typedef std::shared_ptr<Observer<T>>

Definition at line 34 of file types.h.

template<typename T >

using wangle::ObservingPipeline = typedef Pipeline<folly::IOBufQueue&, T>

Definition at line 71 of file ObservingHandler.h.

typedef OutboundHandler<std::unique_ptr<folly::IOBuf> > wangle::OutboundBytesToBytesHandler

Definition at line 179 of file Handler.h.

using wangle::PeekingCallbackPtr = typedef PeekingAcceptorHandshakeHelper::PeekCallback*

Definition at line 138 of file PeekingAcceptorHandshakeHelper.h.

typedef std::map<std::string, PendingLookup> wangle::PendingLookupMap

Definition at line 105 of file SSLSessionCacheManager.h.

typedef std::shared_ptr<folly::Executor> wangle::SchedulerPtr

Definition at line 27 of file types.h.

typedef Pipeline<IOBufQueue&, std::string> wangle::ServicePipeline

Definition at line 32 of file ServiceTest.cpp.

typedef folly::EvictingCacheMap<std::string, SSL_SESSION*> wangle::SSLSessionCacheMap

Basic SSL session cache map: Maps session id -> session

Definition at line 28 of file SSLSessionCacheManager.h.

using wangle::SSLSessionEstablishedCallbackUniquePtr = typedef std::unique_ptr<SSLSessionEstablishedCallback>

Definition at line 36 of file BaseClientBootstrap.h.

typedef std::unique_ptr<SSL_SESSION, SessionDestructor> wangle::SSLSessionPtr

Definition at line 32 of file SSLSession.h.

template<class T >

using wangle::SubjectPtr = typedef std::shared_ptr<Subject<T>>

Definition at line 35 of file types.h.

Enumeration Type Documentation

enum wangle::CertCrypto

strong

Enumerator
BEST_AVAILABLE
SHA1_SIGNATURE

Definition at line 24 of file SSLContextSelectionMisc.h.

                      {
  BEST_AVAILABLE,
  SHA1_SIGNATURE
};

enum wangle::ConnEvent

strong

Enumerator
CONN_ADDED
CONN_REMOVED

Definition at line 266 of file Pipeline.h.

                     {
  CONN_ADDED,
  CONN_REMOVED,
};

enum wangle::HandlerDir

strong

Enumerator
IN
OUT
BOTH

Definition at line 117 of file HandlerContext.h.

                      {
  IN,
  OUT,
  BOTH
};

enum wangle::SecureTransportType

strong

An enum representing different kinds of secure transports we can negotiate.

Enumerator
NONE
TLS
ZERO

Definition at line 26 of file SecureTransportType.h.

                               {
  NONE, // Transport is not secure.
  TLS,  // Transport is based on TLS
  ZERO, // Transport is based on zero protocol
};

enum wangle::SSLErrorEnum

strong

Enumerator
NO_ERROR
TIMEOUT
DROPPED

Definition at line 42 of file SSLUtil.h.

                        {
  NO_ERROR,
  TIMEOUT,
  DROPPED,
};

enum wangle::SSLResumeEnum : uint8_t

strong

SSL session establish/resume status

changing these values will break logging pipelines

Enumerator
HANDSHAKE
RESUME_SESSION_ID
RESUME_TICKET
NA

Definition at line 35 of file SSLUtil.h.

                         : uint8_t {
  HANDSHAKE = 0,
  RESUME_SESSION_ID = 1,
  RESUME_TICKET = 3,
  NA = 2,
};

Function Documentation

SSL_SESSION * wangle::cloneSSLSession

(

SSL_SESSION *

toClone

)

Definition at line 131 of file SSLSessionCacheUtils.cpp.

References getSessionServiceIdentity(), folly::gen::move, and setSessionServiceIdentity().

Referenced by TEST_F().

                                                   {
  if (!toClone) {
    return nullptr;
  }

#ifdef WANGLE_HAVE_SSL_SESSION_DUP
  return SSL_SESSION_dup(toClone);
#else
  auto sessionData = sessionToFbString(toClone);
  if (!sessionData) {
    return nullptr;
  }
  auto clone = fbStringToSession(std::move(*sessionData));

  if (!clone) {
    return nullptr;
  }
  auto serviceIdentity = getSessionServiceIdentity(toClone);
  if (serviceIdentity) {
    setSessionServiceIdentity(clone, serviceIdentity.value());
  }
  return clone;
#endif
}

SSLSessionPtr wangle::createPersistentTestSession

(

std::pair< SSL_SESSION *, size_t >

session

)

Definition at line 350 of file TestUtil.cpp.

Referenced by TEST_F(), and TEST_F().

                                           {
  if (session.first) {
    // This simulates what openssl does before handing control to the cache.
    SSL_SESSION_up_ref(session.first);
  }
  return SSLSessionPtr(session.first);
}

folly::AsyncSocket::OptionMap wangle::filterIPSocketOptions	(	const folly::AsyncSocket::OptionMap &	allOptions,
		const int	addrFamily
	)

Returns a copy of the socket options excluding options with the given level.

Definition at line 24 of file SocketOptions.cpp.

References folly::FATAL.

Referenced by wangle::ServerSocketConfig::setSocketOptions().

                        {
  AsyncSocket::OptionMap opts;
  int exclude;
  if (addrFamily == AF_INET) {
    exclude = IPPROTO_IPV6;
  } else if (addrFamily == AF_INET6) {
    exclude = IPPROTO_IP;
  } else {
    LOG(FATAL) << "Address family " << addrFamily << " was not IPv4 or IPv6";
  }
  for (const auto& opt: allOptions) {
    if (opt.first.level != exclude) {
      opts[opt.first] = opt.second;
    }
  }
  return opts;
}

folly::Optional< SSLSessionCacheData > wangle::getCacheDataForSession

(

SSL_SESSION *

sess

)

Definition at line 99 of file SSLSessionCacheUtils.cpp.

References getSessionServiceIdentity(), and folly::gen::move.

Referenced by wangle::SSLSessionPersistentCacheBase< K >::setSSLSession(), and TEST_F().

                                                                             {
  auto sessionData = sessionToFbString(sess);
  if (!sessionData) {
    return folly::Optional<SSLSessionCacheData>();
  }
  SSLSessionCacheData result;
  result.sessionData = std::move(*sessionData);
  auto serviceIdentity = getSessionServiceIdentity(sess);
  if (serviceIdentity) {
    result.serviceIdentity = std::move(*serviceIdentity);
  }
#ifdef WANGLE_HAVE_SSL_SESSION_DUP
  result.sessionDuplicateTemplate =
      std::shared_ptr<SSL_SESSION>(SSL_SESSION_dup(sess), SessionDestructor{});
#endif
  return result;
}

std::string wangle::getPersistentCacheFilename

(

)

Definition at line 22 of file TestUtil.cpp.

References folly::test::TemporaryFile::path().

Referenced by testEmptyFile(), testInvalidFile(), testSimplePutGet(), testValidFile(), and TYPED_TEST().

                                       {
  folly::test::TemporaryFile file("fbtls");
  return file.path().string();
}

std::string wangle::getSecureTransportName

(

const SecureTransportType &

type

)

Definition at line 20 of file SecureTransportType.cpp.

References TLS, and ZERO.

                                                                  {
  switch (type) {
  case SecureTransportType::TLS:
    return "TLS";
  case SecureTransportType::ZERO:
    return "Zero";
  default:
    return "";
  }
}

std::string wangle::getSessionData	(	SSL_SESSION *	s,
		size_t	expectedLength
	)

Definition at line 359 of file TestUtil.cpp.

References string.

Referenced by isSameSession().

                                                                {
  std::unique_ptr<unsigned char[]>
    sessionData(new unsigned char[expectedLength]);
  auto p = sessionData.get();
  auto len = (size_t)i2d_SSL_SESSION(s, &p);
  CHECK(expectedLength == len);
  return std::string(reinterpret_cast<const char*>(sessionData.get()), len);
}

SSL_SESSION * wangle::getSessionFromCacheData

(

const SSLSessionCacheData &

data

)

Definition at line 117 of file SSLSessionCacheUtils.cpp.

References wangle::SSLSessionCacheData::serviceIdentity, wangle::SSLSessionCacheData::sessionData, wangle::SSLSessionCacheData::sessionDuplicateTemplate, setSessionServiceIdentity(), and folly::basic_fbstring< E, T, A, Storage >::toStdString().

Referenced by wangle::SSLSessionPersistentCacheBase< K >::getSSLSession(), and TEST_F().

                                                                      {
#ifdef WANGLE_HAVE_SSL_SESSION_DUP
  if (data.sessionDuplicateTemplate) {
    return SSL_SESSION_dup(data.sessionDuplicateTemplate.get());
  }
#endif
  auto result = fbStringToSession(data.sessionData);
  if (!result) {
    return nullptr;
  }
  setSessionServiceIdentity(result, data.serviceIdentity.toStdString());
  return result;
}

std::vector< std::pair< SSL_SESSION *, size_t > > wangle::getSessions

(

)

Definition at line 320 of file TestUtil.cpp.

References i, isSameSession(), kNumSessions, and s.

Referenced by SSLSessionCacheDataTest::SetUp(), wangle::SSLSessionPersistentCacheTest::SetUp(), and ThreadSafeSSLSessionCacheTest::SetUp().

                                                       {
  std::vector<std::pair<SSL_SESSION*, size_t>> sessions;

  for (size_t i = 0; i < kNumSessions; ++i) {
    const unsigned char* p = kSessionData[i];
    auto s = d2i_SSL_SESSION(nullptr, &p, kSessionDataLen);
    CHECK(s) << "Invalid session " << i;
    sessions.emplace_back(s, kSessionDataLen);

    // Make sure the same session compares same to itself.
    CHECK(isSameSession(sessions[i], sessions[i]));
  }
  // Make sure all sessions are different from each other
  CHECK(!isSameSession(sessions[0], sessions[1]));
  CHECK(!isSameSession(sessions[1], sessions[2]));
  CHECK(!isSameSession(sessions[2], sessions[0]));

  return sessions;
}

folly::Optional< std::string > wangle::getSessionServiceIdentity

(

SSL_SESSION *

session

)

Definition at line 88 of file SSLSessionCacheUtils.cpp.

References data, and string.

Referenced by cloneSSLSession(), getCacheDataForSession(), wangle::SSLSessionCallbacks::removeSessionCallback(), and TEST_F().

                                                {
  if (!session) {
    return folly::Optional<std::string>();
  }
  auto data = SSL_SESSION_get_ex_data(session, getSessionServiceIdentityIdx());
  if (!data) {
    return folly::Optional<std::string>();
  }
  return *(reinterpret_cast<std::string*>(data));
}

std::pair< SSL_SESSION *, size_t > wangle::getSessionWithTicket

(

)

Definition at line 340 of file TestUtil.cpp.

References isSameSession(), kSessionDataWithTicket, and s.

Referenced by wangle::SSLSessionPersistentCacheTest::SetUp().

                                                     {
  const unsigned char* p = kSessionDataWithTicket;
  size_t sessionDataWithTicketLen = sizeof(kSessionDataWithTicket);
  auto s = d2i_SSL_SESSION(nullptr, &p, sessionDataWithTicketLen);
  CHECK(isSameSession(
        std::make_pair(s, sessionDataWithTicketLen),
        std::make_pair(s, sessionDataWithTicketLen)));
  return std::make_pair(s, sessionDataWithTicketLen);
}

bool wangle::isSameSession	(	std::pair< SSL_SESSION *, size_t >	lhs,
		std::pair< SSL_SESSION *, size_t >	rhs
	)

Definition at line 368 of file TestUtil.cpp.

References getSessionData().

Referenced by getSessions(), getSessionWithTicket(), and wangle::SSLSessionPersistentCacheTest::verifyEntryInCache().

                                       {
  return getSessionData(lhs.first, lhs.second) ==
    getSessionData(rhs.first, rhs.second);
}

std::ostream & wangle::operator<<	(	std::ostream &	os,
		const ManagedConnection &	conn
	)

Definition at line 59 of file ManagedConnection.cpp.

References wangle::ManagedConnection::describe().

                                                          {
  conn.describe(os);
  return os;
}

bool wangle::setSessionServiceIdentity	(	SSL_SESSION *	session,
		const std::string &	str
	)

Definition at line 78 of file SSLSessionCacheUtils.cpp.

References string.

Referenced by cloneSSLSession(), getSessionFromCacheData(), wangle::SSLSessionCallbacks::newSessionCallback(), and TEST_F().

                                                                      {
  if (!session || str.empty()) {
    return false;
  }
  auto serviceExData = new std::string(str);
  return SSL_SESSION_set_ex_data(
    session, getSessionServiceIdentityIdx(), serviceExData) > 0;
}

wangle::TEST	(	SSLContextManagerTest	,
		Test1
	)

Definition at line 35 of file SSLContextManagerTest.cpp.

References EXPECT_EQ, EXPECT_FALSE, wangle::SSLContextManager::getSSLCtxByExactDomain(), wangle::SSLContextManager::getSSLCtxBySuffix(), wangle::SSLContextManager::insertSSLCtxByDomainName(), and folly::EventBase::loop().

{
  EventBase eventBase;
  SSLContextManagerForTest sslCtxMgr(&eventBase,
                                     "vip_ssl_context_manager_test_",
                                     true,
                                     nullptr);
  auto www_facebook_com_ctx = std::make_shared<SSLContext>();
  auto start_facebook_com_ctx = std::make_shared<SSLContext>();
  auto start_abc_facebook_com_ctx = std::make_shared<SSLContext>();
  auto www_facebook_com_ctx_sha1 = std::make_shared<SSLContext>();
  auto start_facebook_com_ctx_sha1 = std::make_shared<SSLContext>();
  auto www_bookface_com_ctx_sha1 = std::make_shared<SSLContext>();

  sslCtxMgr.insertSSLCtxByDomainName(
    "*.facebook.com",
    strlen("*.facebook.com"),
    start_facebook_com_ctx_sha1,
    CertCrypto::SHA1_SIGNATURE);
  sslCtxMgr.insertSSLCtxByDomainName(
    "www.facebook.com",
    strlen("www.facebook.com"),
    www_facebook_com_ctx);
  sslCtxMgr.insertSSLCtxByDomainName(
    "www.facebook.com",
    strlen("www.facebook.com"),
    www_facebook_com_ctx);
  sslCtxMgr.insertSSLCtxByDomainName(
    "*.facebook.com",
    strlen("*.facebook.com"),
    start_facebook_com_ctx);
  sslCtxMgr.insertSSLCtxByDomainName(
    "*.abc.facebook.com",
    strlen("*.abc.facebook.com"),
    start_abc_facebook_com_ctx);
  sslCtxMgr.insertSSLCtxByDomainName(
    "www.facebook.com",
    strlen("www.facebook.com"),
    www_facebook_com_ctx_sha1,
    CertCrypto::SHA1_SIGNATURE);
  sslCtxMgr.insertSSLCtxByDomainName(
    "www.bookface.com",
    strlen("www.bookface.com"),
    www_bookface_com_ctx_sha1,
    CertCrypto::SHA1_SIGNATURE);


  shared_ptr<SSLContext> retCtx;
  retCtx = sslCtxMgr.getSSLCtxByExactDomain(SSLContextKey("www.facebook.com"));
  EXPECT_EQ(retCtx, www_facebook_com_ctx);
  retCtx = sslCtxMgr.getSSLCtxByExactDomain(SSLContextKey("WWW.facebook.com"));
  EXPECT_EQ(retCtx, www_facebook_com_ctx);
  EXPECT_FALSE(
      sslCtxMgr.getSSLCtxByExactDomain(SSLContextKey("xyz.facebook.com")));

  retCtx = sslCtxMgr.getSSLCtxBySuffix(SSLContextKey("xyz.facebook.com"));
  EXPECT_EQ(retCtx, start_facebook_com_ctx);
  retCtx = sslCtxMgr.getSSLCtxBySuffix(SSLContextKey("XYZ.facebook.com"));
  EXPECT_EQ(retCtx, start_facebook_com_ctx);

  retCtx = sslCtxMgr.getSSLCtxBySuffix(SSLContextKey("www.abc.facebook.com"));
  EXPECT_EQ(retCtx, start_abc_facebook_com_ctx);

  // ensure "facebook.com" does not match "*.facebook.com"
  EXPECT_FALSE(sslCtxMgr.getSSLCtxBySuffix(SSLContextKey("facebook.com")));
  // ensure "Xfacebook.com" does not match "*.facebook.com"
  EXPECT_FALSE(sslCtxMgr.getSSLCtxBySuffix(SSLContextKey("Xfacebook.com")));
  // ensure wildcard name only matches one domain up
  EXPECT_FALSE(sslCtxMgr.getSSLCtxBySuffix(
        SSLContextKey("abc.xyz.facebook.com")));

  retCtx = sslCtxMgr.getSSLCtxByExactDomain(SSLContextKey("www.facebook.com",
        CertCrypto::SHA1_SIGNATURE));
  EXPECT_EQ(retCtx, www_facebook_com_ctx_sha1);
  retCtx = sslCtxMgr.getSSLCtxBySuffix(SSLContextKey("abc.facebook.com",
        CertCrypto::SHA1_SIGNATURE));
  EXPECT_EQ(retCtx, start_facebook_com_ctx_sha1);
  retCtx = sslCtxMgr.getSSLCtxBySuffix(SSLContextKey("xyz.abc.facebook.com",
        CertCrypto::SHA1_SIGNATURE));
  EXPECT_FALSE(retCtx);

  retCtx = sslCtxMgr.getSSLCtxByExactDomain(SSLContextKey("www.bookface.com",
        CertCrypto::SHA1_SIGNATURE));
  EXPECT_EQ(retCtx, www_bookface_com_ctx_sha1);
  retCtx = sslCtxMgr.getSSLCtxByExactDomain(SSLContextKey("www.bookface.com"));
  EXPECT_EQ(retCtx, www_bookface_com_ctx_sha1);


  eventBase.loop(); // Clean up events before SSLContextManager is destructed
}

wangle::TEST	(	Wangle	,
		ClientServerTest
	)

Definition at line 114 of file ServiceTest.cpp.

References addr, wangle::ServerBootstrap< Pipeline >::bind(), wangle::ServerBootstrap< Pipeline >::childPipeline(), EXPECT_EQ, folly::EventBaseManager::get(), folly::EventBaseManager::getEventBase(), folly::getEventBase(), wangle::ServerBootstrap< Pipeline >::getSockets(), folly::EventBase::loopForever(), folly::gen::move, wangle::ServerBootstrap< Pipeline >::stop(), string, folly::EventBase::terminateLoopSoon(), and value.

                               {
  // server
  ServerBootstrap<ServicePipeline> server;
  server.childPipeline(
    std::make_shared<ServerPipelineFactory<std::string, std::string>>());
  server.bind(0);

  // client
  auto client = std::make_shared<ClientBootstrap<ServicePipeline>>();
  ClientServiceFactory<ServicePipeline, std::string, std::string> serviceFactory;
  client->pipelineFactory(
    std::make_shared<ClientPipelineFactory<std::string, std::string>>());
  SocketAddress addr;
  server.getSockets()[0]->getAddress(&addr);
  client->connect(addr).waitVia(EventBaseManager::get()->getEventBase());

  auto service = serviceFactory(client).value();
  auto rep = (*service)("test");

  std::move(rep).thenValue([&](std::string value) {
    EXPECT_EQ("test", value);
    EventBaseManager::get()->getEventBase()->terminateLoopSoon();
  });
  EventBaseManager::get()->getEventBase()->loopForever();
  server.stop();
}

wangle::TEST	(	SSLContextManagerTest	,
		DISABLED_TestSessionContextIfSupplied
	)

Definition at line 129 of file SSLContextManagerTest.cpp.

References wangle::SSLContextConfig::addCertificate(), addr, wangle::SSLContextManager::addSSLContextConfig(), ASSERT_NE, EXPECT_EQ, wangle::SSLContextManager::getSSLCtx(), folly::EventBase::loop(), wangle::SSLContextConfig::sessionContext, and string.

{
  EventBase eventBase;
  SSLContextManagerForTest sslCtxMgr(&eventBase,
                                     "vip_ssl_context_manager_test_",
                                     true,
                                     nullptr);
  SSLContextConfig ctxConfig;
  ctxConfig.sessionContext = "test";
  ctxConfig.addCertificate(
      "wangle/ssl/test/certs/test.cert.pem",
      "wangle/ssl/test/certs/test.key.pem",
      "");

  SSLCacheOptions cacheOptions;
  SocketAddress addr;

  sslCtxMgr.addSSLContextConfig(
      ctxConfig, cacheOptions, nullptr, addr, nullptr);

  SSLContextKey key("test.com", CertCrypto::BEST_AVAILABLE);
  auto ctx = sslCtxMgr.getSSLCtx(key);
  ASSERT_NE(ctx, nullptr);
  auto sessCtxFromCtx = std::string(
      reinterpret_cast<char*>(ctx->getSSLCtx()->sid_ctx),
      ctx->getSSLCtx()->sid_ctx_length);
  EXPECT_EQ(*ctxConfig.sessionContext, sessCtxFromCtx);
  eventBase.loop();
}

wangle::TEST	(	SSLContextManagerTest	,
		DISABLED_TestSessionContextIfSessionCacheAbsent
	)

Definition at line 160 of file SSLContextManagerTest.cpp.

References wangle::SSLContextConfig::addCertificate(), addr, wangle::SSLContextManager::addSSLContextConfig(), ASSERT_NE, EXPECT_EQ, wangle::SSLContextManager::getSSLCtx(), folly::EventBase::loop(), wangle::SSLContextConfig::sessionCacheEnabled, wangle::SSLContextConfig::sessionContext, and string.

{
  EventBase eventBase;
  SSLContextManagerForTest sslCtxMgr(&eventBase,
                                     "vip_ssl_context_manager_test_",
                                     true,
                                     nullptr);
  SSLContextConfig ctxConfig;
  ctxConfig.sessionContext = "test";
  ctxConfig.sessionCacheEnabled = false;
  ctxConfig.addCertificate(
      "wangle/ssl/test/certs/test.cert.pem",
      "wangle/ssl/test/certs/test.key.pem",
      "");

  SSLCacheOptions cacheOptions;
  SocketAddress addr;

  sslCtxMgr.addSSLContextConfig(
      ctxConfig, cacheOptions, nullptr, addr, nullptr);

  SSLContextKey key("test.com", CertCrypto::BEST_AVAILABLE);
  auto ctx = sslCtxMgr.getSSLCtx(key);
  ASSERT_NE(ctx, nullptr);
  auto sessCtxFromCtx = std::string(
      reinterpret_cast<char*>(ctx->getSSLCtx()->sid_ctx),
      ctx->getSSLCtx()->sid_ctx_length);
  EXPECT_EQ(*ctxConfig.sessionContext, sessCtxFromCtx);
  eventBase.loop();
}

wangle::TEST	(	Wangle	,
		FilterTest
	)

Definition at line 165 of file ServiceTest.cpp.

References EXPECT_EQ, and folly::pushmi::operators::filter.

                         {
  auto service = std::make_shared<EchoService>();
  auto filter = std::make_shared<AppendFilter>(service);
  auto result = (*filter)("test");
  EXPECT_EQ(result.value(), "test\n");
}

wangle::TEST	(	Wangle	,
		ComplexFilterTest
	)

Definition at line 172 of file ServiceTest.cpp.

References EXPECT_EQ, and folly::pushmi::operators::filter.

                                {
  auto service = std::make_shared<EchoService>();
  auto filter = std::make_shared<IntToStringFilter>(service);
  auto result = (*filter)(1);
  EXPECT_EQ(result.value(), 1);
}

wangle::TEST	(	Wangle	,
		SuperComplexFilterTest
	)

Definition at line 193 of file ServiceTest.cpp.

References EXPECT_EQ, and folly::pushmi::operators::filter.

                                     {
  auto service = std::make_shared<EchoIntService>();
  auto filter = std::make_shared<ChangeTypeFilter>(service);
  auto result = (*filter)(1);
  EXPECT_EQ(result.value(), "1");
}

wangle::TEST	(	Wangle	,
		ServiceFactoryFilter
	)

Definition at line 216 of file ServiceTest.cpp.

References addr, wangle::ServerBootstrap< Pipeline >::bind(), wangle::ServerBootstrap< Pipeline >::childPipeline(), EXPECT_EQ, folly::EventBaseManager::get(), folly::getEventBase(), wangle::ServerBootstrap< Pipeline >::getSockets(), wangle::ServerBootstrap< Pipeline >::stop(), and value.

                                   {
  // server
  ServerBootstrap<ServicePipeline> server;
  server.childPipeline(
    std::make_shared<ServerPipelineFactory<std::string, std::string>>());
  server.bind(0);

  // client
  auto clientFactory =
    std::make_shared<
    ClientServiceFactory<ServicePipeline, std::string, std::string>>();
  auto countingFactory =
    std::make_shared<
    ConnectionCountFilter<ServicePipeline, std::string, std::string>>(
      clientFactory);

  auto client = std::make_shared<ClientBootstrap<ServicePipeline>>();
  client->pipelineFactory(
    std::make_shared<ClientPipelineFactory<std::string, std::string>>());
  SocketAddress addr;
  server.getSockets()[0]->getAddress(&addr);
  client->connect(addr).waitVia(EventBaseManager::get()->getEventBase());

  auto service = (*countingFactory)(client).value();

  // After the first service goes away, the client can be reused
  service = (*countingFactory)(client).value();
  EXPECT_EQ(2, countingFactory->connectionCount);

  server.stop();
}

wangle::TEST	(	Wangle	,
		FactoryToService
	)

Definition at line 248 of file ServiceTest.cpp.

References EXPECT_EQ, and value.

                               {
  auto constfactory =
    std::make_shared<ConstFactory<ServicePipeline, std::string, std::string>>(
    std::make_shared<EchoService>());
  FactoryToService<ServicePipeline, std::string, std::string> service(
    constfactory);

  EXPECT_EQ("test", service("test").value());
}

wangle::TEST	(	ServiceFilter	,
		ExpiringMax
	)

Definition at line 276 of file ServiceTest.cpp.

References EXPECT_EQ, EXPECT_TRUE, and wangle::TimekeeperTester::promises_.

                                 {
  TimekeeperTester timekeeper;

  std::shared_ptr<Service<std::string, std::string>> service =
    std::make_shared<EchoService>();
  std::shared_ptr<Service<std::string, std::string>> closeOnReleaseService =
    std::make_shared<CloseOnReleaseFilter<std::string, std::string>>(service);
  std::shared_ptr<Service<std::string, std::string>> expiringService =
    std::make_shared<ExpiringFilter<std::string, std::string>>(
      closeOnReleaseService,
      std::chrono::milliseconds(0),
      std::chrono::milliseconds(400),
      &timekeeper);

  EXPECT_EQ("test", (*expiringService)("test").get());
  timekeeper.promises_[0].setValue();
  EXPECT_TRUE((*expiringService)("test").getTry().hasException());
}

wangle::TEST	(	ServiceFilter	,
		ExpiringIdle
	)

Definition at line 295 of file ServiceTest.cpp.

References EXPECT_EQ, and wangle::TimekeeperTester::promises_.

                                  {
  TimekeeperTester timekeeper;

  std::shared_ptr<Service<std::string, std::string>> service =
    std::make_shared<EchoService>();
  std::shared_ptr<Service<std::string, std::string>> closeOnReleaseService =
    std::make_shared<CloseOnReleaseFilter<std::string, std::string>>(service);
  std::shared_ptr<Service<std::string, std::string>> expiringService =
    std::make_shared<ExpiringFilter<std::string, std::string>>(
      closeOnReleaseService,
      std::chrono::milliseconds(100),
      std::chrono::milliseconds(0),
      &timekeeper);

  EXPECT_EQ(1, timekeeper.promises_.size());
}

wangle::TEST	(	ServiceFilter	,
		NoIdleDuringRequests
	)

Definition at line 312 of file ServiceTest.cpp.

References EXPECT_EQ, f, folly::gen::move, and wangle::TimekeeperTester::promises_.

                                          {
  TimekeeperTester timekeeper;

  std::shared_ptr<Service<std::string, std::string>> service =
    std::make_shared<EchoService>();
  std::shared_ptr<Service<std::string, std::string>> closeOnReleaseService =
    std::make_shared<CloseOnReleaseFilter<std::string, std::string>>(service);
  std::shared_ptr<Service<std::string, std::string>> expiringService =
    std::make_shared<ExpiringFilter<std::string, std::string>>(
      closeOnReleaseService,
      std::chrono::milliseconds(1),
      std::chrono::milliseconds(0),
      &timekeeper);

  auto f = (*expiringService)("2000");
  EXPECT_EQ(2, timekeeper.promises_.size());
  std::move(f).get();
  EXPECT_EQ("2000", (*expiringService)("2000").get());
  EXPECT_EQ(3, timekeeper.promises_.size());
}

wangle::TEST_F	(	AcceptorTest	,
		TestCanAcceptWithNoConnectionCounter
	)

Definition at line 78 of file AcceptorTest.cpp.

References acceptor_, and EXPECT_TRUE.

                                                           {
  acceptor_.setLoadShedConfig(loadShedConfig_, nullptr);
  // Should accept if there is no IConnectionCounter set
  EXPECT_TRUE(acceptor_.canAccept(address_));
}

wangle::TEST_F	(	AcceptorTest	,
		TestCanAcceptWithMaxConnectionsZero
	)

Definition at line 84 of file AcceptorTest.cpp.

References acceptor_, and EXPECT_TRUE.

                                                          {
  // Should accept if maxConnections is zero
  connectionCounter_.setMaxConnections(0);
  EXPECT_TRUE(acceptor_.canAccept(address_));
}

wangle::TEST_F	(	AcceptorTest	,
		TestCanAcceptWithCurrentConnsLessThanMax
	)

Definition at line 90 of file AcceptorTest.cpp.

References acceptor_, and EXPECT_TRUE.

                                                               {
  // Should accept if currentConnections is less than maxConnections
  connectionCounter_.setNumConnections(100);
  connectionCounter_.setMaxConnections(200);
  EXPECT_TRUE(acceptor_.canAccept(address_));
}

wangle::TEST_F	(	AcceptorTest	,
		TestCanAcceptWithCurrentConnsGreaterThanMax
	)

Definition at line 97 of file AcceptorTest.cpp.

References acceptor_, and EXPECT_FALSE.

                                                                  {
  // Should not accept if currentConnections is larger than maxConnections
  connectionCounter_.setNumConnections(300);
  connectionCounter_.setMaxConnections(200);
  acceptor_.setConnectionCountForLoadShedding(300);
  loadShedConfig_->setMaxConnections(200);
  acceptor_.setLoadShedConfig(loadShedConfig_, &connectionCounter_);
  EXPECT_FALSE(acceptor_.canAccept(address_));
}

wangle::TEST_F	(	SSLSessionPersistentCacheTest	,
		Basic
	)

Definition at line 103 of file SSLSessionPersistentCacheTest.cpp.

References ASSERT_EQ, ASSERT_FALSE, createPersistentTestSession(), i, and folly::sformat().

                                             {
  for (size_t i = 0; i < sessions_.size(); ++i) {
    auto hostname = folly::sformat("host{}", i);

    // The session data does not exist before set.
    ASSERT_EQ(i, cache_->size());
    ASSERT_FALSE(cache_->getSSLSession(hostname));

    cache_->setSSLSession(hostname, createPersistentTestSession(sessions_[i]));

    // The session data should exist before set.
    ASSERT_EQ(i + 1, cache_->size());
    verifyEntryInCache(hostname, sessions_[i]);
  }

  // The previously inserted sessions shouldn't have changed. Then remove them
  // one by one and verify they are not in cache after the removal.
  for (size_t i = 0; i < sessions_.size(); ++i) {
    auto hostname = folly::sformat("host{}", i);
    verifyEntryInCache(hostname, sessions_[i]);
    cache_->removeSSLSession(hostname);
    verifyEntryInCache(hostname, sessions_[i], false);
  }
}

wangle::TEST_F	(	AcceptorTest	,
		TestCanAcceptWhiteListedAddress
	)

Definition at line 107 of file AcceptorTest.cpp.

References acceptor_, and EXPECT_TRUE.

                                                      {
  // Should accept if currentConnections is larger than maxConnections
  // but the address is whitelisted
  connectionCounter_.setNumConnections(300);
  connectionCounter_.setMaxConnections(200);
  LoadShedConfiguration::AddressSet addrs = { address_ };
  loadShedConfig_->setWhitelistAddrs(addrs);
  acceptor_.setLoadShedConfig(loadShedConfig_, &connectionCounter_);
  EXPECT_TRUE(acceptor_.canAccept(address_));
}

wangle::TEST_F	(	AcceptorTest	,
		TestCanAcceptWithNoLoadShed
	)

Definition at line 118 of file AcceptorTest.cpp.

References acceptor_, and EXPECT_TRUE.

                                                  {
  // Should accept if currentConnections is larger than maxConnections,
  // the address is not whitelisted and the current active and total connections
  // counts are below the corresponding thresholds
  connectionCounter_.setNumConnections(300);
  connectionCounter_.setMaxConnections(200);
  loadShedConfig_->setMaxActiveConnections(100);
  loadShedConfig_->setMaxConnections(200);
  acceptor_.setLoadShedConfig(loadShedConfig_, &connectionCounter_);
  EXPECT_TRUE(acceptor_.canAccept(address_));
}

wangle::TEST_F	(	SSLSessionPersistentCacheTest	,
		BadSession
	)

Definition at line 128 of file SSLSessionPersistentCacheTest.cpp.

References ASSERT_EQ, ASSERT_FALSE, createPersistentTestSession(), and string.

                                                  {
  std::string badHost = "bad";

  // Insert bad session to an empty cache.
  cache_->setSSLSession(badHost, SSLSessionPtr(nullptr));
  ASSERT_FALSE(cache_->getSSLSession(badHost));
  ASSERT_EQ(0, cache_->size());

  cache_->setSSLSession("host0", createPersistentTestSession(sessions_[0]));
  cache_->setSSLSession("host1", createPersistentTestSession(sessions_[1]));

  // Insert bad session to non-empty cache
  cache_->setSSLSession(badHost, SSLSessionPtr(nullptr));
  ASSERT_FALSE(cache_->getSSLSession(badHost));
  ASSERT_EQ(2, cache_->size());

  verifyEntryInCache("host0", sessions_[0]);
  verifyEntryInCache("host1", sessions_[1]);
}

wangle::TEST_F	(	AcceptorTest	,
		TestCanAcceptWithMaxActiveConnectionsNotSet
	)

Definition at line 130 of file AcceptorTest.cpp.

References acceptor_, and EXPECT_TRUE.

                                                                  {
  // Should accept if max active connections threshold is not set and
  // total connections is within the overall max connections limit
  connectionCounter_.setNumConnections(300);
  connectionCounter_.setMaxConnections(200);
  loadShedConfig_->setMaxConnections(400);
  acceptor_.setLoadShedConfig(loadShedConfig_, &connectionCounter_);
  acceptor_.setActiveConnectionCountForLoadShedding(300);
  acceptor_.setConnectionCountForLoadShedding(300);
  EXPECT_TRUE(acceptor_.canAccept(address_));
}

wangle::TEST_F	(	AcceptorTest	,
		TestCanAcceptWithActiveConnectionsBreachingThreshold
	)

Definition at line 142 of file AcceptorTest.cpp.

References acceptor_, and EXPECT_FALSE.

                                                                           {
  // Should not accept if currentConnections is larger than maxConnections,
  // the address is not whitelisted and the current active connection is larger
  // than the threshold
  connectionCounter_.setNumConnections(300);
  connectionCounter_.setMaxConnections(200);
  loadShedConfig_->setMaxActiveConnections(100);
  loadShedConfig_->setMaxConnections(200);
  acceptor_.setLoadShedConfig(loadShedConfig_, &connectionCounter_);
  acceptor_.setActiveConnectionCountForLoadShedding(110);
  EXPECT_FALSE(acceptor_.canAccept(address_));
}

wangle::TEST_F	(	SSLSessionPersistentCacheTest	,
		Overwrite
	)

Definition at line 148 of file SSLSessionPersistentCacheTest.cpp.

References createPersistentTestSession().

                                                 {
  cache_->setSSLSession("host0", createPersistentTestSession(sessions_[0]));
  cache_->setSSLSession("host1", createPersistentTestSession(sessions_[1]));

  {
    // Overwrite host1 with a nullptr, the cache shouldn't have changed.
    cache_->setSSLSession("host1", SSLSessionPtr(nullptr));
    verifyEntryInCache("host0", sessions_[0]);
    verifyEntryInCache("host1", sessions_[1]);
  }

  {
    // Valid overwrite.
    cache_->setSSLSession("host1", createPersistentTestSession(sessions_[3]));
    verifyEntryInCache("host0", sessions_[0]);
    verifyEntryInCache("host1", sessions_[3]);
  }

}

wangle::TEST_F	(	AcceptorTest	,
		TestCanAcceptWithTotalConnectionsBreachingThreshold
	)

Definition at line 155 of file AcceptorTest.cpp.

References acceptor_, and EXPECT_FALSE.

                                                                          {
  // Should not accept if currentConnections is larger than maxConnections,
  // the address is not whitelisted and the current connection is larger
  // than the threshold
  connectionCounter_.setNumConnections(300);
  connectionCounter_.setMaxConnections(200);
  loadShedConfig_->setMaxActiveConnections(100);
  loadShedConfig_->setMaxConnections(200);
  acceptor_.setLoadShedConfig(loadShedConfig_, &connectionCounter_);
  acceptor_.setConnectionCountForLoadShedding(210);
  EXPECT_FALSE(acceptor_.canAccept(address_));
}

wangle::TEST_F	(	AcceptorTest	,
		TestCanAcceptWithBothConnectionCountsBreachingThresholds
	)

Definition at line 168 of file AcceptorTest.cpp.

References acceptor_, and EXPECT_FALSE.

                                                                               {
  // Should not accept if currentConnections is larger than maxConnections,
  // the address is not whitelisted and the both current active and total
  // connections counts are larger than the corresponding thresholds
  connectionCounter_.setNumConnections(300);
  connectionCounter_.setMaxConnections(200);
  loadShedConfig_->setMaxActiveConnections(100);
  loadShedConfig_->setMaxConnections(200);
  acceptor_.setLoadShedConfig(loadShedConfig_, &connectionCounter_);
  acceptor_.setActiveConnectionCountForLoadShedding(110);
  acceptor_.setConnectionCountForLoadShedding(210);
  EXPECT_FALSE(acceptor_.canAccept(address_));
}

wangle::TEST_F	(	SSLSessionPersistentCacheTest	,
		SessionTicketTimeout
	)

Definition at line 168 of file SSLSessionPersistentCacheTest.cpp.

References ASSERT_FALSE, ASSERT_NE, ASSERT_TRUE, createPersistentTestSession(), s, folly::portability::ssl::SSL_SESSION_get_ticket_lifetime_hint(), folly::portability::ssl::SSL_SESSION_has_ticket(), and string.

                                                            {
  std::string myhost("host3");
  cache_->setSSLSession(
      myhost,
      createPersistentTestSession(sessionWithTicket_));

  // First verify element is successfully added to the cache
  auto s = cache_->getSSLSession(myhost);
  ASSERT_TRUE(s != nullptr);
  ASSERT_NE(SSL_SESSION_has_ticket(s.get()), 0);
  verifyEntryInCache(myhost, sessions_[3]);

  // Verify that if element is added to cache within
  // tlsext_tick_lifetime_hint seconds ago, we can retrieve it

  // advance current time by slightly less than tlsext_tick_lifetime_hint
  // Ticket should still be in cache
  long lifetime_seconds = SSL_SESSION_get_ticket_lifetime_hint(s.get());
  mockTimeUtil_->advance(
      duration_cast<milliseconds>(seconds(lifetime_seconds - 10)));

  verifyEntryInCache(myhost, sessions_[3]);

  // advance current time to >= tlsext_tick_lifetime_hint
  // Ticket should not be in cache
  mockTimeUtil_->advance(duration_cast<milliseconds>(seconds(15)));
  ASSERT_FALSE(cache_->getSSLSession(myhost));
}

template<typename K , typename V , typename MutexT = std::mutex>

void wangle::testSimplePutGet	(	const std::vector< K > &	keys,
		const std::vector< V > &	values
	)

Definition at line 32 of file TestUtil.h.

References EXPECT_EQ, EXPECT_FALSE, EXPECT_TRUE, getPersistentCacheFilename(), and string.

                                {
  std::string filename = getPersistentCacheFilename();
  typedef FilePersistentCache<K, V, MutexT> CacheType;
  size_t cacheCapacity = 10;
  {
    CacheType cache(filename, cacheCapacity, std::chrono::seconds(150));
    EXPECT_FALSE(cache.get(keys[0]).hasValue());
    EXPECT_FALSE(cache.get(keys[1]).hasValue());
    cache.put(keys[0], values[0]);
    cache.put(keys[1], values[1]);
    EXPECT_EQ(cache.size(), 2);
    EXPECT_EQ(cache.get(keys[0]).value(), values[0]);
    EXPECT_EQ(cache.get(keys[1]).value(), values[1]);
  }
  {
    CacheType cache(filename, cacheCapacity, std::chrono::seconds(150));
    EXPECT_EQ(cache.size(), 2);
    EXPECT_EQ(cache.get(keys[0]).value(), values[0]);
    EXPECT_EQ(cache.get(keys[1]).value(), values[1]);
    EXPECT_TRUE(cache.remove(keys[1]));
    EXPECT_FALSE(cache.remove(keys[1]));
    EXPECT_EQ(cache.size(), 1);
    EXPECT_EQ(cache.get(keys[0]).value(), values[0]);
    EXPECT_FALSE(cache.get(keys[1]).hasValue());
  }
  {
    CacheType cache(filename, cacheCapacity, std::chrono::seconds(150));
    EXPECT_EQ(cache.size(), 1);
    EXPECT_EQ(cache.get(keys[0]).value(), values[0]);
    EXPECT_FALSE(cache.get(keys[1]).hasValue());
    cache.clear();
    EXPECT_EQ(cache.size(), 0);
    EXPECT_FALSE(cache.get(keys[0]).hasValue());
    EXPECT_FALSE(cache.get(keys[1]).hasValue());
  }
  {
    CacheType cache(filename, cacheCapacity, std::chrono::seconds(150));
    EXPECT_EQ(cache.size(), 0);
    EXPECT_FALSE(cache.get(keys[0]).hasValue());
    EXPECT_FALSE(cache.get(keys[1]).hasValue());
  }
  EXPECT_TRUE(unlink(filename.c_str()) != -1);
}

Variable Documentation

const std::string wangle::empty_string

static

Definition at line 24 of file SSLAcceptorHandshakeHelper.cpp.

const std::string wangle::empty_string

static

Definition at line 51 of file Acceptor.cpp.

Referenced by wangle::SSLAcceptorHandshakeHelper::handshakeSuc().

const size_t wangle::kNumSessions = 3

Definition at line 20 of file TestUtil.cpp.

Referenced by getSessions().

const unsigned char wangle::kSessionData[kNumSessions][kSessionDataLen]

Definition at line 24 of file TestUtil.cpp.

const size_t wangle::kSessionDataLen = 1060

Definition at line 21 of file TestUtil.cpp.

const unsigned char wangle::kSessionDataWithTicket[]

Definition at line 218 of file TestUtil.cpp.

Referenced by getSessionWithTicket().