Skip to content

F
folly
Commit ef1c65ad authored by James Sedgwick's avatar James Sedgwick Committed by Pavlo Kushnir
Browse files
Options

move folly/wangle to wangle 

Summary: this preserves history and will be followed by a copy diff

Test Plan: next diff will compile

Reviewed By: hans@fb.com

Subscribers: fugalh, ps, bmatheny, folly-diffs@, jsedgwick, yfeldblum, markdrayton, chalfant

FB internal diff: D2100784

Tasks: 5802833

Signature: t1:2100784:1432677219:838a336d84918145d19c6cfa4290dd58374821fd
parent a716b86b
Hide whitespace changes
Inline Side-by-side
Showing with 0 additions and 13765 deletions
folly/wangle/acceptor/Acceptor.cpp deleted 100644 → 0
View file @ a716b86b
/*
* Copyright (c) 2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
*/
#include <folly/wangle/acceptor/Acceptor.h>
#include <folly/wangle/acceptor/ManagedConnection.h>
#include <folly/wangle/ssl/SSLContextManager.h>
#include <boost/cast.hpp>
#include <fcntl.h>
#include <folly/ScopeGuard.h>
#include <folly/io/async/EventBase.h>
#include <fstream>
#include <sys/socket.h>
#include <sys/types.h>
#include <folly/io/async/AsyncSSLSocket.h>
#include <folly/io/async/AsyncSocket.h>
#include <gflags/gflags.h>
#include <unistd.h>
using folly::wangle::ConnectionManager;
using folly::wangle::ManagedConnection;
using std::chrono::microseconds;
using std::chrono::milliseconds;
using std::filebuf;
using std::ifstream;
using std::ios;
using std::shared_ptr;
using std::string;
namespace folly {
#ifndef NO_LIB_GFLAGS
DEFINE_int32(shutdown_idle_grace_ms, 5000, "milliseconds to wait before "
"closing idle conns");
#else
const int32_t FLAGS_shutdown_idle_grace_ms = 5000;
#endif
static const std::string empty_string;
std::atomic<uint64_t> Acceptor::totalNumPendingSSLConns_{0};
/**
* Lightweight wrapper class to keep track of a newly
* accepted connection during SSL handshaking.
*/
class AcceptorHandshakeHelper :
public AsyncSSLSocket::HandshakeCB,
public ManagedConnection {
public:
AcceptorHandshakeHelper(AsyncSSLSocket::UniquePtr socket,
Acceptor* acceptor,
const SocketAddress& clientAddr,
std::chrono::steady_clock::time_point acceptTime,
TransportInfo& tinfo)
: socket_(std::move(socket)), acceptor_(acceptor),
acceptTime_(acceptTime), clientAddr_(clientAddr),
tinfo_(tinfo) {
acceptor_->downstreamConnectionManager_->addConnection(this, true);
if(acceptor_->parseClientHello_) {
socket_->enableClientHelloParsing();
}
socket_->sslAccept(this);
}
virtual void timeoutExpired() noexcept override {
VLOG(4) << "SSL handshake timeout expired";
sslError_ = SSLErrorEnum::TIMEOUT;
dropConnection();
}
virtual void describe(std::ostream& os) const override {
os << "pending handshake on " << clientAddr_;
}
virtual bool isBusy() const override {
return true;
}
virtual void notifyPendingShutdown() override {}
virtual void closeWhenIdle() override {}
virtual void dropConnection() override {
VLOG(10) << "Dropping in progress handshake for " << clientAddr_;
socket_->closeNow();
}
virtual void dumpConnectionState(uint8_t loglevel) override {
}
private:
// AsyncSSLSocket::HandshakeCallback API
virtual void handshakeSuc(AsyncSSLSocket* sock) noexcept override {
const unsigned char* nextProto = nullptr;
unsigned nextProtoLength = 0;
sock->getSelectedNextProtocol(&nextProto, &nextProtoLength);
if (VLOG_IS_ON(3)) {
if (nextProto) {
VLOG(3) << "Client selected next protocol " <<
string((const char*)nextProto, nextProtoLength);
} else {
VLOG(3) << "Client did not select a next protocol";
}
}
// fill in SSL-related fields from TransportInfo
// the other fields like RTT are filled in the Acceptor
tinfo_.ssl = true;
tinfo_.acceptTime = acceptTime_;
tinfo_.sslSetupTime = std::chrono::duration_cast<std::chrono::milliseconds>(
std::chrono::steady_clock::now() - acceptTime_
);
tinfo_.sslSetupBytesRead = sock->getRawBytesReceived();
tinfo_.sslSetupBytesWritten = sock->getRawBytesWritten();
tinfo_.sslServerName = sock->getSSLServerName() ?
std::make_shared<std::string>(sock->getSSLServerName()) : nullptr;
tinfo_.sslCipher = sock->getNegotiatedCipherName() ?
std::make_shared<std::string>(sock->getNegotiatedCipherName()) : nullptr;
tinfo_.sslVersion = sock->getSSLVersion();
tinfo_.sslCertSize = sock->getSSLCertSize();
tinfo_.sslResume = SSLUtil::getResumeState(sock);
tinfo_.sslClientCiphers = std::make_shared<std::string>();
sock->getSSLClientCiphers(*tinfo_.sslClientCiphers);
tinfo_.sslServerCiphers = std::make_shared<std::string>();
sock->getSSLServerCiphers(*tinfo_.sslServerCiphers);
tinfo_.sslClientComprMethods =
std::make_shared<std::string>(sock->getSSLClientComprMethods());
tinfo_.sslClientExts =
std::make_shared<std::string>(sock->getSSLClientExts());
tinfo_.sslNextProtocol = std::make_shared<std::string>();
tinfo_.sslNextProtocol->assign(reinterpret_cast<const char*>(nextProto),
nextProtoLength);
acceptor_->updateSSLStats(
sock,
tinfo_.sslSetupTime,
SSLErrorEnum::NO_ERROR
);
acceptor_->downstreamConnectionManager_->removeConnection(this);
acceptor_->sslConnectionReady(std::move(socket_), clientAddr_,
nextProto ? string((const char*)nextProto, nextProtoLength) :
empty_string, tinfo_);
delete this;
}
virtual void handshakeErr(AsyncSSLSocket* sock,
const AsyncSocketException& ex) noexcept override {
auto elapsedTime = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::steady_clock::now() - acceptTime_);
VLOG(3) << "SSL handshake error after " << elapsedTime.count() <<
" ms; " << sock->getRawBytesReceived() << " bytes received & " <<
sock->getRawBytesWritten() << " bytes sent: " <<
ex.what();
acceptor_->updateSSLStats(sock, elapsedTime, sslError_);
acceptor_->sslConnectionError();
delete this;
}
AsyncSSLSocket::UniquePtr socket_;
Acceptor* acceptor_;
std::chrono::steady_clock::time_point acceptTime_;
SocketAddress clientAddr_;
TransportInfo tinfo_;
SSLErrorEnum sslError_{SSLErrorEnum::NO_ERROR};
};
Acceptor::Acceptor(const ServerSocketConfig& accConfig) :
accConfig_(accConfig),
socketOptions_(accConfig.getSocketOptions()) {
}
void
Acceptor::init(AsyncServerSocket* serverSocket,
EventBase* eventBase) {
CHECK(nullptr == this->base_);
if (accConfig_.isSSL()) {
if (!sslCtxManager_) {
sslCtxManager_ = folly::make_unique<SSLContextManager>(
eventBase,
"vip_" + getName(),
accConfig_.strictSSL, nullptr);
}
for (const auto& sslCtxConfig : accConfig_.sslContextConfigs) {
sslCtxManager_->addSSLContextConfig(
sslCtxConfig,
accConfig_.sslCacheOptions,
&accConfig_.initialTicketSeeds,
accConfig_.bindAddress,
cacheProvider_);
parseClientHello_ |= sslCtxConfig.clientHelloParsingEnabled;
}
CHECK(sslCtxManager_->getDefaultSSLCtx());
}
base_ = eventBase;
state_ = State::kRunning;
downstreamConnectionManager_ = ConnectionManager::makeUnique(
eventBase, accConfig_.connectionIdleTimeout, this);
if (serverSocket) {
serverSocket->addAcceptCallback(this, eventBase);
for (auto& fd : serverSocket->getSockets()) {
if (fd < 0) {
continue;
}
for (const auto& opt: socketOptions_) {
opt.first.apply(fd, opt.second);
}
}
}
}
Acceptor::~Acceptor(void) {
}
void Acceptor::addSSLContextConfig(const SSLContextConfig& sslCtxConfig) {
sslCtxManager_->addSSLContextConfig(sslCtxConfig,
accConfig_.sslCacheOptions,
&accConfig_.initialTicketSeeds,
accConfig_.bindAddress,
cacheProvider_);
}
void
Acceptor::drainAllConnections() {
if (downstreamConnectionManager_) {
downstreamConnectionManager_->initiateGracefulShutdown(
std::chrono::milliseconds(FLAGS_shutdown_idle_grace_ms));
}
}
void Acceptor::setLoadShedConfig(const LoadShedConfiguration& from,
IConnectionCounter* counter) {
loadShedConfig_ = from;
connectionCounter_ = counter;
}
bool Acceptor::canAccept(const SocketAddress& address) {
if (!connectionCounter_) {
return true;
}
uint64_t maxConnections = connectionCounter_->getMaxConnections();
if (maxConnections == 0) {
return true;
}
uint64_t currentConnections = connectionCounter_->getNumConnections();
if (currentConnections < maxConnections) {
return true;
}
if (loadShedConfig_.isWhitelisted(address)) {
return true;
}
// Take care of comparing connection count against max connections across
// all acceptors. Expensive since a lock must be taken to get the counter.
auto connectionCountForLoadShedding = getConnectionCountForLoadShedding();
if (connectionCountForLoadShedding < loadShedConfig_.getMaxConnections()) {
return true;
}
VLOG(4) << address.describe() << " not whitelisted";
return false;
}
void
Acceptor::connectionAccepted(
int fd, const SocketAddress& clientAddr) noexcept {
if (!canAccept(clientAddr)) {
close(fd);
return;
}
auto acceptTime = std::chrono::steady_clock::now();
for (const auto& opt: socketOptions_) {
opt.first.apply(fd, opt.second);
}
onDoneAcceptingConnection(fd, clientAddr, acceptTime);
}
void Acceptor::onDoneAcceptingConnection(
int fd,
const SocketAddress& clientAddr,
std::chrono::steady_clock::time_point acceptTime) noexcept {
TransportInfo tinfo;
processEstablishedConnection(fd, clientAddr, acceptTime, tinfo);
}
void
Acceptor::processEstablishedConnection(
int fd,
const SocketAddress& clientAddr,
std::chrono::steady_clock::time_point acceptTime,
TransportInfo& tinfo) noexcept {
if (accConfig_.isSSL()) {
CHECK(sslCtxManager_);
AsyncSSLSocket::UniquePtr sslSock(
makeNewAsyncSSLSocket(
sslCtxManager_->getDefaultSSLCtx(), base_, fd));
++numPendingSSLConns_;
++totalNumPendingSSLConns_;
if (totalNumPendingSSLConns_ > accConfig_.maxConcurrentSSLHandshakes) {
VLOG(2) << "dropped SSL handshake on " << accConfig_.name <<
" too many handshakes in progress";
updateSSLStats(sslSock.get(), std::chrono::milliseconds(0),
SSLErrorEnum::DROPPED);
sslConnectionError();
return;
}
new AcceptorHandshakeHelper(
std::move(sslSock),
this,
clientAddr,
acceptTime,
tinfo
);
} else {
tinfo.ssl = false;
tinfo.acceptTime = acceptTime;
AsyncSocket::UniquePtr sock(makeNewAsyncSocket(base_, fd));
connectionReady(std::move(sock), clientAddr, empty_string, tinfo);
}
}
void
Acceptor::connectionReady(
AsyncSocket::UniquePtr sock,
const SocketAddress& clientAddr,
const string& nextProtocolName,
TransportInfo& tinfo) {
// Limit the number of reads from the socket per poll loop iteration,
// both to keep memory usage under control and to prevent one fast-
// writing client from starving other connections.
sock->setMaxReadsPerEvent(16);
tinfo.initWithSocket(sock.get());
onNewConnection(std::move(sock), &clientAddr, nextProtocolName, tinfo);
}
void
Acceptor::sslConnectionReady(AsyncSocket::UniquePtr sock,
const SocketAddress& clientAddr,
const string& nextProtocol,
TransportInfo& tinfo) {
CHECK(numPendingSSLConns_ > 0);
connectionReady(std::move(sock), clientAddr, nextProtocol, tinfo);
--numPendingSSLConns_;
--totalNumPendingSSLConns_;
if (state_ == State::kDraining) {
checkDrained();
}
}
void
Acceptor::sslConnectionError() {
CHECK(numPendingSSLConns_ > 0);
--numPendingSSLConns_;
--totalNumPendingSSLConns_;
if (state_ == State::kDraining) {
checkDrained();
}
}
void
Acceptor::acceptError(const std::exception& ex) noexcept {
// An error occurred.
// The most likely error is out of FDs. AsyncServerSocket will back off
// briefly if we are out of FDs, then continue accepting later.
// Just log a message here.
LOG(ERROR) << "error accepting on acceptor socket: " << ex.what();
}
void
Acceptor::acceptStopped() noexcept {
VLOG(3) << "Acceptor " << this << " acceptStopped()";
// Drain the open client connections
drainAllConnections();
// If we haven't yet finished draining, begin doing so by marking ourselves
// as in the draining state. We must be sure to hit checkDrained() here, as
// if we're completely idle, we can should consider ourself drained
// immediately (as there is no outstanding work to complete to cause us to
// re-evaluate this).
if (state_ != State::kDone) {
state_ = State::kDraining;
checkDrained();
}
}
void
Acceptor::onEmpty(const ConnectionManager& cm) {
VLOG(3) << "Acceptor=" << this << " onEmpty()";
if (state_ == State::kDraining) {
checkDrained();
}
}
void
Acceptor::checkDrained() {
CHECK(state_ == State::kDraining);
if (forceShutdownInProgress_ ||
(downstreamConnectionManager_->getNumConnections() != 0) ||
(numPendingSSLConns_ != 0)) {
return;
}
VLOG(2) << "All connections drained from Acceptor=" << this << " in thread "
<< base_;
downstreamConnectionManager_.reset();
state_ = State::kDone;
onConnectionsDrained();
}
milliseconds
Acceptor::getConnTimeout() const {
return accConfig_.connectionIdleTimeout;
}
void Acceptor::addConnection(ManagedConnection* conn) {
// Add the socket to the timeout manager so that it can be cleaned
// up after being left idle for a long time.
downstreamConnectionManager_->addConnection(conn, true);
}
void
Acceptor::forceStop() {
base_->runInEventBaseThread([&] { dropAllConnections(); });
}
void
Acceptor::dropAllConnections() {
if (downstreamConnectionManager_) {
VLOG(3) << "Dropping all connections from Acceptor=" << this <<
" in thread " << base_;
assert(base_->isInEventBaseThread());
forceShutdownInProgress_ = true;
downstreamConnectionManager_->dropAllConnections();
CHECK(downstreamConnectionManager_->getNumConnections() == 0);
downstreamConnectionManager_.reset();
}
CHECK(numPendingSSLConns_ == 0);
state_ = State::kDone;
onConnectionsDrained();
}
} // namespace
folly/wangle/acceptor/Acceptor.h deleted 100644 → 0
View file @ a716b86b
/*
* Copyright (c) 2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
*/
#pragma once
#include <folly/wangle/acceptor/ServerSocketConfig.h>
#include <folly/wangle/acceptor/ConnectionCounter.h>
#include <folly/wangle/acceptor/ConnectionManager.h>
#include <folly/wangle/acceptor/LoadShedConfiguration.h>
#include <folly/wangle/ssl/SSLCacheProvider.h>
#include <folly/wangle/acceptor/TransportInfo.h>
#include <chrono>
#include <event.h>
#include <folly/io/async/AsyncSSLSocket.h>
#include <folly/io/async/AsyncServerSocket.h>
#include <folly/io/async/AsyncUDPServerSocket.h>
namespace folly { namespace wangle {
class ManagedConnection;
}}
namespace folly {
class SocketAddress;
class SSLContext;
class AsyncTransport;
class SSLContextManager;
/**
* An abstract acceptor for TCP-based network services.
*
* There is one acceptor object per thread for each listening socket. When a
* new connection arrives on the listening socket, it is accepted by one of the
* acceptor objects. From that point on the connection will be processed by
* that acceptor's thread.
*
* The acceptor will call the abstract onNewConnection() method to create
* a new ManagedConnection object for each accepted socket. The acceptor
* also tracks all outstanding connections that it has accepted.
*/
class Acceptor :
public folly::AsyncServerSocket::AcceptCallback,
public folly::wangle::ConnectionManager::Callback,
public AsyncUDPServerSocket::Callback {
public:
enum class State : uint32_t {
kInit, // not yet started
kRunning, // processing requests normally
kDraining, // processing outstanding conns, but not accepting new ones
kDone, // no longer accepting, and all connections finished
};
explicit Acceptor(const ServerSocketConfig& accConfig);
virtual ~Acceptor();
/**
* Supply an SSL cache provider
* @note Call this before init()
*/
virtual void setSSLCacheProvider(
const std::shared_ptr<SSLCacheProvider>& cacheProvider) {
cacheProvider_ = cacheProvider;
}
/**
* Initialize the Acceptor to run in the specified EventBase
* thread, receiving connections from the specified AsyncServerSocket.
*
* This method will be called from the AsyncServerSocket's primary thread,
* not the specified EventBase thread.
*/
virtual void init(AsyncServerSocket* serverSocket,
EventBase* eventBase);
/**
* Dynamically add a new SSLContextConfig
*/
void addSSLContextConfig(const SSLContextConfig& sslCtxConfig);
SSLContextManager* getSSLContextManager() const {
return sslCtxManager_.get();
}
/**
* Return the number of outstanding connections in this service instance.
*/
uint32_t getNumConnections() const {
return downstreamConnectionManager_ ?
(uint32_t)downstreamConnectionManager_->getNumConnections() : 0;
}
/**
* Access the Acceptor's event base.
*/
virtual EventBase* getEventBase() const { return base_; }
/**
* Access the Acceptor's downstream (client-side) ConnectionManager
*/
virtual folly::wangle::ConnectionManager* getConnectionManager() {
return downstreamConnectionManager_.get();
}
/**
* Invoked when a new ManagedConnection is created.
*
* This allows the Acceptor to track the outstanding connections,
* for tracking timeouts and for ensuring that all connections have been
* drained on shutdown.
*/
void addConnection(folly::wangle::ManagedConnection* connection);
/**
* Get this acceptor's current state.
*/
State getState() const {
return state_;
}
/**
* Get the current connection timeout.
*/
std::chrono::milliseconds getConnTimeout() const;
/**
* Returns the name of this VIP.
*
* Will return an empty string if no name has been configured.
*/
const std::string& getName() const {
return accConfig_.name;
}
/**
* Force the acceptor to drop all connections and stop processing.
*
* This function may be called from any thread. The acceptor will not
* necessarily stop before this function returns: the stop will be scheduled
* to run in the acceptor's thread.
*/
virtual void forceStop();
bool isSSL() const { return accConfig_.isSSL(); }
const ServerSocketConfig& getConfig() const { return accConfig_; }
static uint64_t getTotalNumPendingSSLConns() {
return totalNumPendingSSLConns_.load();
}
/**
* Called right when the TCP connection has been accepted, before processing
* the first HTTP bytes (HTTP) or the SSL handshake (HTTPS)
*/
virtual void onDoneAcceptingConnection(
int fd,
const SocketAddress& clientAddr,
std::chrono::steady_clock::time_point acceptTime
) noexcept;
/**
* Begins either processing HTTP bytes (HTTP) or the SSL handshake (HTTPS)
*/
void processEstablishedConnection(
int fd,
const SocketAddress& clientAddr,
std::chrono::steady_clock::time_point acceptTime,
TransportInfo& tinfo
) noexcept;
/**
* Drains all open connections of their outstanding transactions. When
* a connection's transaction count reaches zero, the connection closes.
*/
void drainAllConnections();
/**
* Drop all connections.
*
* forceStop() schedules dropAllConnections() to be called in the acceptor's
* thread.
*/
void dropAllConnections();
protected:
friend class AcceptorHandshakeHelper;
/**
* Our event loop.
*
* Probably needs to be used to pass to a ManagedConnection
* implementation. Also visible in case a subclass wishes to do additional
* things w/ the event loop (e.g. in attach()).
*/
EventBase* base_{nullptr};
virtual uint64_t getConnectionCountForLoadShedding(void) const { return 0; }
/**
* Hook for subclasses to drop newly accepted connections prior
* to handshaking.
*/
virtual bool canAccept(const folly::SocketAddress&);
/**
* Invoked when a new connection is created. This is where application starts
* processing a new downstream connection.
*
* NOTE: Application should add the new connection to
* downstreamConnectionManager so that it can be garbage collected after
* certain period of idleness.
*
* @param sock the socket connected to the client
* @param address the address of the client
* @param nextProtocolName the name of the L6 or L7 protocol to be
* spoken on the connection, if known (e.g.,
* from TLS NPN during secure connection setup),
* or an empty string if unknown
*/
virtual void onNewConnection(
AsyncSocket::UniquePtr sock,
const folly::SocketAddress* address,
const std::string& nextProtocolName,
const TransportInfo& tinfo) {}
void onListenStarted() noexcept {}
void onListenStopped() noexcept {}
void onDataAvailable(
std::shared_ptr<AsyncUDPSocket> socket,
const SocketAddress&,
std::unique_ptr<IOBuf>, bool) noexcept {}
virtual AsyncSocket::UniquePtr makeNewAsyncSocket(EventBase* base, int fd) {
return AsyncSocket::UniquePtr(new AsyncSocket(base, fd));
}
virtual AsyncSSLSocket::UniquePtr makeNewAsyncSSLSocket(
const std::shared_ptr<SSLContext>& ctx, EventBase* base, int fd) {
return AsyncSSLSocket::UniquePtr(new AsyncSSLSocket(ctx, base, fd));
}
/**
* Hook for subclasses to record stats about SSL connection establishment.
*/
virtual void updateSSLStats(
const AsyncSSLSocket* sock,
std::chrono::milliseconds acceptLatency,
SSLErrorEnum error) noexcept {}
protected:
/**
* onConnectionsDrained() will be called once all connections have been
* drained while the acceptor is stopping.
*
* Subclasses can override this method to perform any subclass-specific
* cleanup.
*/
virtual void onConnectionsDrained() {}
// AsyncServerSocket::AcceptCallback methods
void connectionAccepted(int fd,
const folly::SocketAddress& clientAddr)
noexcept;
void acceptError(const std::exception& ex) noexcept;
void acceptStopped() noexcept;
// ConnectionManager::Callback methods
void onEmpty(const folly::wangle::ConnectionManager& cm);
void onConnectionAdded(const folly::wangle::ConnectionManager& cm) {}
void onConnectionRemoved(const folly::wangle::ConnectionManager& cm) {}
/**
* Process a connection that is to ready to receive L7 traffic.
* This method is called immediately upon accept for plaintext
* connections and upon completion of SSL handshaking or resumption
* for SSL connections.
*/
void connectionReady(
AsyncSocket::UniquePtr sock,
const folly::SocketAddress& clientAddr,
const std::string& nextProtocolName,
TransportInfo& tinfo);
const LoadShedConfiguration& getLoadShedConfiguration() const {
return loadShedConfig_;
}
protected:
const ServerSocketConfig accConfig_;
void setLoadShedConfig(const LoadShedConfiguration& from,
IConnectionCounter* counter);
/**
* Socket options to apply to the client socket
*/
AsyncSocket::OptionMap socketOptions_;
std::unique_ptr<SSLContextManager> sslCtxManager_;
/**
* Whether we want to enable client hello parsing in the handshake helper
* to get list of supported client ciphers.
*/
bool parseClientHello_{false};
folly::wangle::ConnectionManager::UniquePtr downstreamConnectionManager_;
private:
// Forbidden copy constructor and assignment opererator
Acceptor(Acceptor const &) = delete;
Acceptor& operator=(Acceptor const &) = delete;
/**
* Wrapper for connectionReady() that decrements the count of
* pending SSL connections.
*/
void sslConnectionReady(AsyncSocket::UniquePtr sock,
const folly::SocketAddress& clientAddr,
const std::string& nextProtocol,
TransportInfo& tinfo);
/**
* Notification callback for SSL handshake failures.
*/
void sslConnectionError();
void checkDrained();
State state_{State::kInit};
uint64_t numPendingSSLConns_{0};
static std::atomic<uint64_t> totalNumPendingSSLConns_;
bool forceShutdownInProgress_{false};
LoadShedConfiguration loadShedConfig_;
IConnectionCounter* connectionCounter_{nullptr};
std::shared_ptr<SSLCacheProvider> cacheProvider_;
};
class AcceptorFactory {
public:
virtual std::shared_ptr<Acceptor> newAcceptor(folly::EventBase*) = 0;
virtual ~AcceptorFactory() = default;
};
} // namespace
folly/wangle/acceptor/ConnectionCounter.h deleted 100644 → 0
View file @ a716b86b
/*
* Copyright (c) 2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
*/
#pragma once
namespace folly {
class IConnectionCounter {
public:
virtual uint64_t getNumConnections() const = 0;
/**
* Get the maximum number of non-whitelisted client-side connections
* across all Acceptors managed by this. A value
* of zero means "unlimited."
*/
virtual uint64_t getMaxConnections() const = 0;
/**
* Increment the count of client-side connections.
*/
virtual void onConnectionAdded() = 0;
/**
* Decrement the count of client-side connections.
*/
virtual void onConnectionRemoved() = 0;
virtual ~IConnectionCounter() {}
};
class SimpleConnectionCounter: public IConnectionCounter {
public:
uint64_t getNumConnections() const override { return numConnections_; }
uint64_t getMaxConnections() const override { return maxConnections_; }
void setMaxConnections(uint64_t maxConnections) {
maxConnections_ = maxConnections;
}
void onConnectionAdded() override { numConnections_++; }
void onConnectionRemoved() override { numConnections_--; }
virtual ~SimpleConnectionCounter() {}
protected:
uint64_t maxConnections_{0};
uint64_t numConnections_{0};
};
}
folly/wangle/acceptor/ConnectionManager.cpp deleted 100644 → 0
View file @ a716b86b
/*
* Copyright 2015 Facebook, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <folly/wangle/acceptor/ConnectionManager.h>
#include <glog/logging.h>
#include <folly/io/async/EventBase.h>
using folly::HHWheelTimer;
using std::chrono::milliseconds;
namespace folly { namespace wangle {
ConnectionManager::ConnectionManager(EventBase* eventBase,
milliseconds timeout, Callback* callback)
: connTimeouts_(new HHWheelTimer(eventBase)),
callback_(callback),
eventBase_(eventBase),
idleIterator_(conns_.end()),
idleLoopCallback_(this),
timeout_(timeout),
idleConnEarlyDropThreshold_(timeout_ / 2) {
}
void
ConnectionManager::addConnection(ManagedConnection* connection,
bool timeout) {
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(*this);
}
}
if (timeout) {
scheduleTimeout(connection, timeout_);
}
}
void
ConnectionManager::scheduleTimeout(ManagedConnection* const connection,
std::chrono::milliseconds timeout) {
if (timeout > std::chrono::milliseconds(0)) {
connTimeouts_->scheduleTimeout(connection, timeout);
}
}
void ConnectionManager::scheduleTimeout(
folly::HHWheelTimer::Callback* callback,
std::chrono::milliseconds timeout) {
connTimeouts_->scheduleTimeout(callback, timeout);
}
void
ConnectionManager::removeConnection(ManagedConnection* connection) {
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 == idleIterator_) {
++idleIterator_;
}
conns_.erase(it);
if (callback_) {
callback_->onConnectionRemoved(*this);
if (getNumConnections() == 0) {
callback_->onEmpty(*this);
}
}
}
}
void
ConnectionManager::initiateGracefulShutdown(
std::chrono::milliseconds idleGrace) {
if (idleGrace.count() > 0) {
idleLoopCallback_.scheduleTimeout(idleGrace);
VLOG(3) << "Scheduling idle grace period of " << idleGrace.count() << "ms";
} else {
action_ = ShutdownAction::DRAIN2;
VLOG(3) << "proceeding directly to closing idle connections";
}
drainAllConnections();
}
void
ConnectionManager::drainAllConnections() {
DestructorGuard g(this);
size_t numCleared = 0;
size_t numKept = 0;
auto it = idleIterator_ == conns_.end() ?
conns_.begin() : idleIterator_;
while (it != conns_.end() && (numKept + numCleared) < 64) {
ManagedConnection& conn = *it++;
if (action_ == ShutdownAction::DRAIN1) {
conn.notifyPendingShutdown();
} else {
// Second time around: close idle sessions. If they aren't idle yet,
// have them close when they are idle
if (conn.isBusy()) {
numKept++;
} else {
numCleared++;
}
conn.closeWhenIdle();
}
}
if (action_ == ShutdownAction::DRAIN2) {
VLOG(2) << "Idle connections cleared: " << numCleared <<
", busy conns kept: " << numKept;
}
if (it != conns_.end()) {
idleIterator_ = it;
eventBase_->runInLoop(&idleLoopCallback_);
} else {
action_ = ShutdownAction::DRAIN2;
}
}
void
ConnectionManager::dropAllConnections() {
DestructorGuard g(this);
// Iterate through our connection list, and drop each connection.
VLOG(3) << "connections to drop: " << conns_.size();
idleLoopCallback_.cancelTimeout();
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();
}
idleIterator_ = conns_.end();
idleLoopCallback_.cancelLoopCallback();
if (callback_) {
callback_->onEmpty(*this);
}
}
void
ConnectionManager::onActivated(ManagedConnection& conn) {
auto it = conns_.iterator_to(conn);
if (it == idleIterator_) {
idleIterator_++;
}
conns_.erase(it);
conns_.push_front(conn);
}
void
ConnectionManager::onDeactivated(ManagedConnection& conn) {
auto it = conns_.iterator_to(conn);
conns_.erase(it);
conns_.push_back(conn);
if (idleIterator_ == conns_.end()) {
idleIterator_--;
}
}
size_t
ConnectionManager::dropIdleConnections(size_t num) {
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.timeoutExpired();
count++;
}
return count;
}
}} // folly::wangle
folly/wangle/acceptor/ConnectionManager.h deleted 100644 → 0
View file @ a716b86b
/*
* Copyright 2015 Facebook, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#pragma once
#include <folly/wangle/acceptor/ManagedConnection.h>
#include <chrono>
#include <folly/Memory.h>
#include <folly/io/async/AsyncTimeout.h>
#include <folly/io/async/HHWheelTimer.h>
#include <folly/io/async/DelayedDestruction.h>
#include <folly/io/async/EventBase.h>
namespace folly { namespace wangle {
/**
* A ConnectionManager keeps track of ManagedConnections.
*/
class ConnectionManager: public folly::DelayedDestruction,
private ManagedConnection::Callback {
public:
/**
* Interface for an optional observer that's notified about
* various events in a ConnectionManager
*/
class Callback {
public:
virtual ~Callback() {}
/**
* Invoked when the number of connections managed by the
* ConnectionManager changes from nonzero to zero.
*/
virtual void onEmpty(const ConnectionManager& cm) = 0;
/**
* Invoked when a connection is added to the ConnectionManager.
*/
virtual void onConnectionAdded(const ConnectionManager& cm) = 0;
/**
* Invoked when a connection is removed from the ConnectionManager.
*/
virtual void onConnectionRemoved(const ConnectionManager& cm) = 0;
};
typedef std::unique_ptr<ConnectionManager, Destructor> UniquePtr;
/**
* Returns a new instance of ConnectionManager wrapped in a unique_ptr
*/
template<typename... Args>
static UniquePtr makeUnique(Args&&... args) {
return folly::make_unique<ConnectionManager, Destructor>(
std::forward<Args>(args)...);
}
/**
* Constructor not to be used by itself.
*/
ConnectionManager(folly::EventBase* eventBase,
std::chrono::milliseconds timeout,
Callback* callback = nullptr);
/**
* Add a connection to the set of connections managed by this
* ConnectionManager.
*
* @param connection The connection to add.
* @param timeout Whether to immediately register this connection
* for an idle timeout callback.
*/
void addConnection(ManagedConnection* connection,
bool timeout = false);
/**
* Schedule a timeout callback for a connection.
*/
void scheduleTimeout(ManagedConnection* const connection,
std::chrono::milliseconds timeout);
/*
* Schedule a callback on the wheel timer
*/
void scheduleTimeout(folly::HHWheelTimer::Callback* callback,
std::chrono::milliseconds timeout);
/**
* 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.
*/
void removeConnection(ManagedConnection* connection);
/* Begin gracefully shutting down connections in this ConnectionManager.
* Notify all connections of pending shutdown, and after idleGrace,
* begin closing idle connections.
*/
void initiateGracefulShutdown(std::chrono::milliseconds idleGrace);
/**
* Destroy all connections Managed by this ConnectionManager, even
* the ones that are busy.
*/
void dropAllConnections();
size_t getNumConnections() const { return conns_.size(); }
template <typename F>
void iterateConns(F func) {
auto it = conns_.begin();
while ( it != conns_.end()) {
func(&(*it));
it++;
}
}
std::chrono::milliseconds getDefaultTimeout() const {
return timeout_;
}
void setLoweredIdleTimeout(std::chrono::milliseconds timeout) {
CHECK(timeout >= std::chrono::milliseconds(0));
CHECK(timeout <= timeout_);
idleConnEarlyDropThreshold_ = timeout;
}
/**
* try to drop num idle connections to release system resources. Return the
* actual number of dropped idle connections
*/
size_t dropIdleConnections(size_t num);
/**
* ManagedConnection::Callbacks
*/
void onActivated(ManagedConnection& conn);
void onDeactivated(ManagedConnection& conn);
private:
class CloseIdleConnsCallback :
public folly::EventBase::LoopCallback,
public folly::AsyncTimeout {
public:
explicit CloseIdleConnsCallback(ConnectionManager* manager)
: folly::AsyncTimeout(manager->eventBase_),
manager_(manager) {}
void runLoopCallback() noexcept override {
VLOG(3) << "Draining more conns from loop callback";
manager_->drainAllConnections();
}
void timeoutExpired() noexcept override {
VLOG(3) << "Idle grace expired";
manager_->drainAllConnections();
}
private:
ConnectionManager* manager_;
};
enum class ShutdownAction : uint8_t {
/**
* Drain part 1: inform remote that you will soon reject new requests.
*/
DRAIN1 = 0,
/**
* Drain part 2: start rejecting new requests.
*/
DRAIN2 = 1,
};
~ConnectionManager() {}
ConnectionManager(const ConnectionManager&) = delete;
ConnectionManager& operator=(ConnectionManager&) = delete;
/**
* Destroy all connections managed by this ConnectionManager that
* are currently idle, as determined by a call to each ManagedConnection's
* isBusy() method.
*/
void drainAllConnections();
/**
* 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. */
folly::CountedIntrusiveList<
ManagedConnection,&ManagedConnection::listHook_> conns_;
/** Connections that currently are registered for timeouts */
folly::HHWheelTimer::UniquePtr connTimeouts_;
/** Optional callback to notify of state changes */
Callback* callback_;
/** Event base in which we run */
folly::EventBase* eventBase_;
/** Iterator to the next connection to shed; used by drainAllConnections() */
folly::CountedIntrusiveList<
ManagedConnection,&ManagedConnection::listHook_>::iterator idleIterator_;
CloseIdleConnsCallback idleLoopCallback_;
ShutdownAction action_{ShutdownAction::DRAIN1};
/**
* the default idle timeout for downstream sessions when no system resource
* limit is reached
*/
std::chrono::milliseconds timeout_;
/**
* 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_.
*/
std::chrono::milliseconds idleConnEarlyDropThreshold_;
};
}} // folly::wangle
folly/wangle/acceptor/DomainNameMisc.h deleted 100644 → 0
View file @ a716b86b
/*
* Copyright (c) 2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
*/
#pragma once
#include <string>
namespace folly {
struct dn_char_traits : public std::char_traits<char> {
static bool eq(char c1, char c2) {
return ::tolower(c1) == ::tolower(c2);
}
static bool ne(char c1, char c2) {
return ::tolower(c1) != ::tolower(c2);
}
static bool lt(char c1, char c2) {
return ::tolower(c1) < ::tolower(c2);
}
static int compare(const char* s1, const char* s2, size_t n) {
while (n--) {
if(::tolower(*s1) < ::tolower(*s2) ) {
return -1;
}
if(::tolower(*s1) > ::tolower(*s2) ) {
return 1;
}
++s1;
++s2;
}
return 0;
}
static const char* find(const char* s, size_t n, char a) {
char la = ::tolower(a);
while (n--) {
if(::tolower(*s) == la) {
return s;
} else {
++s;
}
}
return nullptr;
}
};
// Case insensitive string
typedef std::basic_string<char, dn_char_traits> DNString;
struct DNStringHash : public std::hash<std::string> {
size_t operator()(const DNString& s1) const noexcept {
std::string s2(s1.data(), s1.size());
for (char& c : s2)
c = ::tolower(c);
return std::hash<std::string>()(s2);
}
};
} // namespace
folly/wangle/acceptor/LoadShedConfiguration.cpp deleted 100644 → 0
View file @ a716b86b
/*
* Copyright (c) 2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
*/
#include <folly/wangle/acceptor/LoadShedConfiguration.h>
#include <folly/Conv.h>
#include <openssl/ssl.h>
using std::string;
namespace folly {
void LoadShedConfiguration::addWhitelistAddr(folly::StringPiece input) {
auto addr = input.str();
size_t separator = addr.find_first_of('/');
if (separator == string::npos) {
whitelistAddrs_.insert(SocketAddress(addr, 0));
} else {
unsigned prefixLen = folly::to<unsigned>(addr.substr(separator + 1));
addr.erase(separator);
whitelistNetworks_.insert(NetworkAddress(SocketAddress(addr, 0), prefixLen));
}
}
bool LoadShedConfiguration::isWhitelisted(const SocketAddress& address) const {
if (whitelistAddrs_.find(address) != whitelistAddrs_.end()) {
return true;
}
for (auto& network : whitelistNetworks_) {
if (network.contains(address)) {
return true;
}
}
return false;
}
}
folly/wangle/acceptor/LoadShedConfiguration.h deleted 100644 → 0
View file @ a716b86b
/*
* Copyright (c) 2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
*/
#pragma once
#include <chrono>
#include <folly/Range.h>
#include <folly/SocketAddress.h>
#include <glog/logging.h>
#include <list>
#include <set>
#include <string>
#include <folly/wangle/acceptor/NetworkAddress.h>
namespace folly {
/**
* Class that holds an LoadShed configuration for a service
*/
class LoadShedConfiguration {
public:
// Comparison function for SocketAddress that disregards the port
struct AddressOnlyCompare {
bool operator()(
const SocketAddress& addr1,
const SocketAddress& addr2) const {
return addr1.getIPAddress() < addr2.getIPAddress();
}
};
typedef std::set<SocketAddress, AddressOnlyCompare> AddressSet;
typedef std::set<NetworkAddress> NetworkSet;
LoadShedConfiguration() {}
~LoadShedConfiguration() {}
void addWhitelistAddr(folly::StringPiece);
/**
* Set/get the set of IPs that should be whitelisted through even when we're
* trying to shed load.
*/
void setWhitelistAddrs(const AddressSet& addrs) { whitelistAddrs_ = addrs; }
const AddressSet& getWhitelistAddrs() const { return whitelistAddrs_; }
/**
* Set/get the set of networks that should be whitelisted through even
* when we're trying to shed load.
*/
void setWhitelistNetworks(const NetworkSet& networks) {
whitelistNetworks_ = networks;
}
const NetworkSet& getWhitelistNetworks() const { return whitelistNetworks_; }
/**
* Set/get the maximum number of downstream connections across all VIPs.
*/
void setMaxConnections(uint64_t maxConns) { maxConnections_ = maxConns; }
uint64_t getMaxConnections() const { return maxConnections_; }
/**
* Set/get the maximum cpu usage.
*/
void setMaxMemUsage(double max) {
CHECK(max >= 0);
CHECK(max <= 1);
maxMemUsage_ = max;
}
double getMaxMemUsage() const { return maxMemUsage_; }
/**
* Set/get the maximum memory usage.
*/
void setMaxCpuUsage(double max) {
CHECK(max >= 0);
CHECK(max <= 1);
maxCpuUsage_ = max;
}
double getMaxCpuUsage() const { return maxCpuUsage_; }
/**
* Set/get the minium actual free memory on the system.
*/
void setMinFreeMem(uint64_t min) {
minFreeMem_ = min;
}
uint64_t getMinFreeMem() const {
return minFreeMem_;
}
void setLoadUpdatePeriod(std::chrono::milliseconds period) {
period_ = period;
}
std::chrono::milliseconds getLoadUpdatePeriod() const { return period_; }
bool isWhitelisted(const SocketAddress& addr) const;
private:
AddressSet whitelistAddrs_;
NetworkSet whitelistNetworks_;
uint64_t maxConnections_{0};
uint64_t minFreeMem_{0};
double maxMemUsage_;
double maxCpuUsage_;
std::chrono::milliseconds period_;
};
}
folly/wangle/acceptor/ManagedConnection.cpp deleted 100644 → 0
View file @ a716b86b
/*
* Copyright 2015 Facebook, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <folly/wangle/acceptor/ManagedConnection.h>
#include <folly/wangle/acceptor/ConnectionManager.h>
namespace folly { namespace wangle {
ManagedConnection::ManagedConnection()
: connectionManager_(nullptr) {
}
ManagedConnection::~ManagedConnection() {
if (connectionManager_) {
connectionManager_->removeConnection(this);
}
}
void
ManagedConnection::resetTimeout() {
if (connectionManager_) {
resetTimeoutTo(connectionManager_->getDefaultTimeout());
}
}
void
ManagedConnection::resetTimeoutTo(std::chrono::milliseconds timeout) {
if (connectionManager_) {
connectionManager_->scheduleTimeout(this, timeout);
}
}
void
ManagedConnection::scheduleTimeout(
folly::HHWheelTimer::Callback* callback,
std::chrono::milliseconds timeout) {
if (connectionManager_) {
connectionManager_->scheduleTimeout(callback, timeout);
}
}
////////////////////// Globals /////////////////////
std::ostream&
operator<<(std::ostream& os, const ManagedConnection& conn) {
conn.describe(os);
return os;
}
}} // folly::wangle
folly/wangle/acceptor/ManagedConnection.h deleted 100644 → 0
View file @ a716b86b
/*
* Copyright 2015 Facebook, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#pragma once
#include <folly/IntrusiveList.h>
#include <ostream>
#include <folly/io/async/HHWheelTimer.h>
#include <folly/io/async/DelayedDestruction.h>
namespace folly { namespace wangle {
class ConnectionManager;
/**
* Interface describing a connection that can be managed by a
* container such as an Acceptor.
*/
class ManagedConnection:
public folly::HHWheelTimer::Callback,
public folly::DelayedDestruction {
public:
ManagedConnection();
class Callback {
public:
virtual ~Callback() {}
/* Invoked when this connection becomes busy */
virtual void onActivated(ManagedConnection& conn) = 0;
/* Invoked when a connection becomes idle */
virtual void onDeactivated(ManagedConnection& conn) = 0;
};
// HHWheelTimer::Callback API (left for subclasses to implement).
virtual void timeoutExpired() noexcept = 0;
/**
* Print a human-readable description of the connection.
* @param os Destination stream.
*/
virtual void describe(std::ostream& os) const = 0;
/**
* Check whether the connection has any requests outstanding.
*/
virtual bool isBusy() const = 0;
/**
* Get the idle time of the connection. If it returning 0, that means the idle
* connections will never be dropped during pre load shedding stage.
*/
virtual std::chrono::milliseconds getIdleTime() const {
return std::chrono::milliseconds(0);
}
/**
* Notify the connection that a shutdown is pending. This method will be
* called at the beginning of graceful shutdown.
*/
virtual void notifyPendingShutdown() = 0;
/**
* Instruct the connection that it should shutdown as soon as it is
* safe. This is called after notifyPendingShutdown().
*/
virtual void closeWhenIdle() = 0;
/**
* Forcibly drop a connection.
*
* If a request is in progress, this should cause the connection to be
* closed with a reset.
*/
virtual void dropConnection() = 0;
/**
* Dump the state of the connection to the log
*/
virtual void dumpConnectionState(uint8_t loglevel) = 0;
/**
* If the connection has a connection manager, reset the timeout countdown to
* connection manager's default timeout.
* @note If the connection manager doesn't have the connection scheduled
* for a timeout already, this method will schedule one. If the
* connection manager does have the connection connection scheduled
* for a timeout, this method will push back the timeout to N msec
* from now, where N is the connection manager's timer interval.
*/
virtual void resetTimeout();
/**
* If the connection has a connection manager, reset the timeout countdown to
* user specified timeout.
*/
void resetTimeoutTo(std::chrono::milliseconds);
// Schedule an arbitrary timeout on the HHWheelTimer
virtual void scheduleTimeout(
folly::HHWheelTimer::Callback* callback,
std::chrono::milliseconds timeout);
ConnectionManager* getConnectionManager() {
return connectionManager_;
}
protected:
virtual ~ManagedConnection();
private:
friend class ConnectionManager;
void setConnectionManager(ConnectionManager* mgr) {
connectionManager_ = mgr;
}
ConnectionManager* connectionManager_;
folly::SafeIntrusiveListHook listHook_;
};
std::ostream& operator<<(std::ostream& os, const ManagedConnection& conn);
}} // folly::wangle
folly/wangle/acceptor/NetworkAddress.h deleted 100644 → 0
View file @ a716b86b
/*
* Copyright (c) 2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
*/
#pragma once
#include <folly/SocketAddress.h>
namespace folly {
/**
* A simple wrapper around SocketAddress that represents
* a network in CIDR notation
*/
class NetworkAddress {
public:
/**
* Create a NetworkAddress for an addr/prefixLen
* @param addr IPv4 or IPv6 address of the network
* @param prefixLen Prefix length, in bits
*/
NetworkAddress(const folly::SocketAddress& addr,
unsigned prefixLen):
addr_(addr), prefixLen_(prefixLen) {}
/** Get the network address */
const folly::SocketAddress& getAddress() const {
return addr_;
}
/** Get the prefix length in bits */
unsigned getPrefixLength() const { return prefixLen_; }
/** Check whether a given address lies within the network */
bool contains(const folly::SocketAddress& addr) const {
return addr_.prefixMatch(addr, prefixLen_);
}
/** Comparison operator to enable use in ordered collections */
bool operator<(const NetworkAddress& other) const {
if (addr_ < other.addr_) {
return true;
} else if (other.addr_ < addr_) {
return false;
} else {
return (prefixLen_ < other.prefixLen_);
}
}
private:
folly::SocketAddress addr_;
unsigned prefixLen_;
};
} // namespace
folly/wangle/acceptor/ServerSocketConfig.h deleted 100644 → 0
View file @ a716b86b
/*
* Copyright (c) 2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
*/
#pragma once
#include <folly/wangle/ssl/SSLCacheOptions.h>
#include <folly/wangle/ssl/SSLContextConfig.h>
#include <folly/wangle/ssl/TLSTicketKeySeeds.h>
#include <folly/wangle/ssl/SSLUtil.h>
#include <folly/wangle/acceptor/SocketOptions.h>
#include <boost/optional.hpp>
#include <chrono>
#include <fcntl.h>
#include <folly/Random.h>
#include <folly/SocketAddress.h>
#include <folly/String.h>
#include <folly/io/async/SSLContext.h>
#include <list>
#include <string>
#include <sys/stat.h>
#include <sys/types.h>
#include <folly/io/async/AsyncSocket.h>
#include <folly/io/async/SSLContext.h>
#include <folly/SocketAddress.h>
namespace folly {
/**
* Configuration for a single Acceptor.
*
* This configures not only accept behavior, but also some types of SSL
* behavior that may make sense to configure on a per-VIP basis (e.g. which
* cert(s) we use, etc).
*/
struct ServerSocketConfig {
ServerSocketConfig() {
// generate a single random current seed
uint8_t seed[32];
folly::Random::secureRandom(seed, sizeof(seed));
initialTicketSeeds.currentSeeds.push_back(
SSLUtil::hexlify(std::string((char *)seed, sizeof(seed))));
}
bool isSSL() const { return !(sslContextConfigs.empty()); }
/**
* Set/get the socket options to apply on all downstream connections.
*/
void setSocketOptions(
const AsyncSocket::OptionMap& opts) {
socketOptions_ = filterIPSocketOptions(opts, bindAddress.getFamily());
}
AsyncSocket::OptionMap&
getSocketOptions() {
return socketOptions_;
}
const AsyncSocket::OptionMap&
getSocketOptions() const {
return socketOptions_;
}
bool hasExternalPrivateKey() const {
for (const auto& cfg : sslContextConfigs) {
if (!cfg.isLocalPrivateKey) {
return true;
}
}
return false;
}
/**
* The name of this acceptor; used for stats/reporting purposes.
*/
std::string name;
/**
* The depth of the accept queue backlog.
*/
uint32_t acceptBacklog{1024};
/**
* The number of milliseconds a connection can be idle before we close it.
*/
std::chrono::milliseconds connectionIdleTimeout{600000};
/**
* The address to bind to.
*/
SocketAddress bindAddress;
/**
* Options for controlling the SSL cache.
*/
SSLCacheOptions sslCacheOptions{std::chrono::seconds(600), 20480, 200};
/**
* The initial TLS ticket seeds.
*/
TLSTicketKeySeeds initialTicketSeeds;
/**
* The configs for all the SSL_CTX for use by this Acceptor.
*/
std::vector<SSLContextConfig> sslContextConfigs;
/**
* Determines if the Acceptor does strict checking when loading the SSL
* contexts.
*/
bool strictSSL{true};
/**
* Maximum number of concurrent pending SSL handshakes
*/
uint32_t maxConcurrentSSLHandshakes{30720};
private:
AsyncSocket::OptionMap socketOptions_;
};
} // folly
folly/wangle/acceptor/SocketOptions.cpp deleted 100644 → 0
View file @ a716b86b
/*
* Copyright (c) 2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
*/
#include <folly/wangle/acceptor/SocketOptions.h>
#include <netinet/tcp.h>
#include <sys/socket.h>
namespace folly {
AsyncSocket::OptionMap filterIPSocketOptions(
const AsyncSocket::OptionMap& allOptions,
const int addrFamily) {
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";
return opts;
}
for (const auto& opt: allOptions) {
if (opt.first.level != exclude) {
opts[opt.first] = opt.second;
}
}
return opts;
}
}
folly/wangle/acceptor/SocketOptions.h deleted 100644 → 0
View file @ a716b86b
/*
* Copyright (c) 2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
*/
#pragma once
#include <folly/io/async/AsyncSocket.h>
namespace folly {
/**
* Returns a copy of the socket options excluding options with the given
* level.
*/
AsyncSocket::OptionMap filterIPSocketOptions(
const AsyncSocket::OptionMap& allOptions,
const int addrFamily);
}
folly/wangle/acceptor/TransportInfo.cpp deleted 100644 → 0
View file @ a716b86b
/*
* Copyright (c) 2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
*/
#include <folly/wangle/acceptor/TransportInfo.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <folly/io/async/AsyncSocket.h>
using std::chrono::microseconds;
using std::map;
using std::string;
namespace folly {
bool TransportInfo::initWithSocket(const AsyncSocket* sock) {
#if defined(__linux__) || defined(__FreeBSD__)
if (!TransportInfo::readTcpInfo(&tcpinfo, sock)) {
tcpinfoErrno = errno;
return false;
}
rtt = microseconds(tcpinfo.tcpi_rtt);
validTcpinfo = true;
#else
tcpinfoErrno = EINVAL;
rtt = microseconds(-1);
#endif
return true;
}
int64_t TransportInfo::readRTT(const AsyncSocket* sock) {
#if defined(__linux__) || defined(__FreeBSD__)
struct tcp_info tcpinfo;
if (!TransportInfo::readTcpInfo(&tcpinfo, sock)) {
return -1;
}
return tcpinfo.tcpi_rtt;
#else
return -1;
#endif
}
#if defined(__linux__) || defined(__FreeBSD__)
bool TransportInfo::readTcpInfo(struct tcp_info* tcpinfo,
const AsyncSocket* sock) {
socklen_t len = sizeof(struct tcp_info);
if (!sock) {
return false;
}
if (getsockopt(sock->getFd(), IPPROTO_TCP,
TCP_INFO, (void*) tcpinfo, &len) < 0) {
VLOG(4) << "Error calling getsockopt(): " << strerror(errno);
return false;
}
return true;
}
#endif
} // folly
folly/wangle/acceptor/TransportInfo.h deleted 100644 → 0
View file @ a716b86b
/*
* Copyright (c) 2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
*/
#pragma once
#include <folly/wangle/ssl/SSLUtil.h>
#include <chrono>
#include <netinet/tcp.h>
#include <string>
namespace folly {
class AsyncSocket;
/**
* A structure that encapsulates byte counters related to the HTTP headers.
*/
struct HTTPHeaderSize {
/**
* The number of bytes used to represent the header after compression or
* before decompression. If header compression is not supported, the value
* is set to 0.
*/
size_t compressed{0};
/**
* The number of bytes used to represent the serialized header before
* compression or after decompression, in plain-text format.
*/
size_t uncompressed{0};
};
struct TransportInfo {
/*
* timestamp of when the connection handshake was completed
*/
std::chrono::steady_clock::time_point acceptTime{};
/*
* connection RTT (Round-Trip Time)
*/
std::chrono::microseconds rtt{0};
#if defined(__linux__) || defined(__FreeBSD__)
/*
* TCP information as fetched from getsockopt(2)
*/
tcp_info tcpinfo {
#if __GLIBC__ >= 2 && __GLIBC_MINOR__ >= 17
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 // 32
#else
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 // 29
#endif // __GLIBC__ >= 2 && __GLIBC_MINOR__ >= 17
};
#endif // defined(__linux__) || defined(__FreeBSD__)
/*
* time for setting the connection, from the moment in was accepted until it
* is established.
*/
std::chrono::milliseconds setupTime{0};
/*
* time for setting up the SSL connection or SSL handshake
*/
std::chrono::milliseconds sslSetupTime{0};
/*
* The name of the SSL ciphersuite used by the transaction's
* transport. Returns null if the transport is not SSL.
*/
std::shared_ptr<std::string> sslCipher{nullptr};
/*
* The SSL server name used by the transaction's
* transport. Returns null if the transport is not SSL.
*/
std::shared_ptr<std::string> sslServerName{nullptr};
/*
* list of ciphers sent by the client
*/
std::shared_ptr<std::string> sslClientCiphers{nullptr};
/*
* list of compression methods sent by the client
*/
std::shared_ptr<std::string> sslClientComprMethods{nullptr};
/*
* list of TLS extensions sent by the client
*/
std::shared_ptr<std::string> sslClientExts{nullptr};
/*
* hash of all the SSL parameters sent by the client
*/
std::shared_ptr<std::string> sslSignature{nullptr};
/*
* list of ciphers supported by the server
*/
std::shared_ptr<std::string> sslServerCiphers{nullptr};
/*
* guessed "(os) (browser)" based on SSL Signature
*/
std::shared_ptr<std::string> guessedUserAgent{nullptr};
/**
* The result of SSL NPN negotiation.
*/
std::shared_ptr<std::string> sslNextProtocol{nullptr};
/*
* total number of bytes sent over the connection
*/
int64_t totalBytes{0};
/**
* If the client passed through one of our L4 proxies (using PROXY Protocol),
* then this will contain the IP address of the proxy host.
*/
std::shared_ptr<folly::SocketAddress> clientAddrOriginal;
/**
* header bytes read
*/
HTTPHeaderSize ingressHeader;
/*
* header bytes written
*/
HTTPHeaderSize egressHeader;
/*
* Here is how the timeToXXXByte variables are planned out:
* 1. All timeToXXXByte variables are measuring the ByteEvent from reqStart_
* 2. You can get the timing between two ByteEvents by calculating their
* differences. For example:
* timeToLastBodyByteAck - timeToFirstByte
* => Total time to deliver the body
* 3. The calculation in point (2) is typically done outside acceptor
*
* Future plan:
* We should log the timestamps (TimePoints) and allow
* the consumer to calculate the latency whatever it
* wants instead of calculating them in wangle, for the sake of flexibility.
* For example:
* 1. TimePoint reqStartTimestamp;
* 2. TimePoint firstHeaderByteSentTimestamp;
* 3. TimePoint firstBodyByteTimestamp;
* 3. TimePoint lastBodyByteTimestamp;
* 4. TimePoint lastBodyByteAckTimestamp;
*/
/*
* time to first header byte written to the kernel send buffer
* NOTE: It is not 100% accurate since TAsyncSocket does not do
* do callback on partial write.
*/
int32_t timeToFirstHeaderByte{-1};
/*
* time to first body byte written to the kernel send buffer
*/
int32_t timeToFirstByte{-1};
/*
* time to last body byte written to the kernel send buffer
*/
int32_t timeToLastByte{-1};
/*
* time to TCP Ack received for the last written body byte
*/
int32_t timeToLastBodyByteAck{-1};
/*
* time it took the client to ACK the last byte, from the moment when the
* kernel sent the last byte to the client and until it received the ACK
* for that byte
*/
int32_t lastByteAckLatency{-1};
/*
* time spent inside wangle
*/
int32_t proxyLatency{-1};
/*
* time between connection accepted and client message headers completed
*/
int32_t clientLatency{-1};
/*
* latency for communication with the server
*/
int32_t serverLatency{-1};
/*
* time used to get a usable connection.
*/
int32_t connectLatency{-1};
/*
* body bytes written
*/
uint32_t egressBodySize{0};
/*
* value of errno in case of getsockopt() error
*/
int tcpinfoErrno{0};
/*
* bytes read & written during SSL Setup
*/
uint32_t sslSetupBytesWritten{0};
uint32_t sslSetupBytesRead{0};
/**
* SSL error detail
*/
uint32_t sslError{0};
/**
* body bytes read
*/
uint32_t ingressBodySize{0};
/*
* The SSL version used by the transaction's transport, in
* OpenSSL's format: 4 bits for the major version, followed by 4 bits
* for the minor version. Returns zero for non-SSL.
*/
uint16_t sslVersion{0};
/*
* The SSL certificate size.
*/
uint16_t sslCertSize{0};
/**
* response status code
*/
uint16_t statusCode{0};
/*
* The SSL mode for the transaction's transport: new session,
* resumed session, or neither (non-SSL).
*/
SSLResumeEnum sslResume{SSLResumeEnum::NA};
/*
* true if the tcpinfo was successfully read from the kernel
*/
bool validTcpinfo{false};
/*
* true if the connection is SSL, false otherwise
*/
bool ssl{false};
/*
* get the RTT value in milliseconds
*/
std::chrono::milliseconds getRttMs() const {
return std::chrono::duration_cast<std::chrono::milliseconds>(rtt);
}
/*
* initialize the fields related with tcp_info
*/
bool initWithSocket(const AsyncSocket* sock);
/*
* Get the kernel's estimate of round-trip time (RTT) to the transport's peer
* in microseconds. Returns -1 on error.
*/
static int64_t readRTT(const AsyncSocket* sock);
#if defined(__linux__) || defined(__FreeBSD__)
/*
* perform the getsockopt(2) syscall to fetch TCP info for a given socket
*/
static bool readTcpInfo(struct tcp_info* tcpinfo,
const AsyncSocket* sock);
#endif
};
} // folly
folly/wangle/bootstrap/BootstrapTest.cpp deleted 100644 → 0
View file @ a716b86b
/*
* Copyright 2015 Facebook, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "folly/wangle/bootstrap/ServerBootstrap.h"
#include "folly/wangle/bootstrap/ClientBootstrap.h"
#include "folly/wangle/channel/Handler.h"
#include <glog/logging.h>
#include <gtest/gtest.h>
#include <boost/thread.hpp>
using namespace folly::wangle;
using namespace folly;
typedef Pipeline<IOBufQueue&, std::unique_ptr<IOBuf>> BytesPipeline;
typedef ServerBootstrap<BytesPipeline> TestServer;
typedef ClientBootstrap<BytesPipeline> TestClient;
class TestClientPipelineFactory : public PipelineFactory<BytesPipeline> {
public:
std::unique_ptr<BytesPipeline, folly::DelayedDestruction::Destructor>
newPipeline(std::shared_ptr<AsyncSocket> sock) {
// We probably aren't connected immedately, check after a small delay
EventBaseManager::get()->getEventBase()->tryRunAfterDelay([sock](){
CHECK(sock->good());
CHECK(sock->readable());
}, 100);
return nullptr;
}
};
class TestPipelineFactory : public PipelineFactory<BytesPipeline> {
public:
std::unique_ptr<BytesPipeline, folly::DelayedDestruction::Destructor> newPipeline(
std::shared_ptr<AsyncSocket> sock) {
pipelines++;
return std::unique_ptr<BytesPipeline, folly::DelayedDestruction::Destructor>(
new BytesPipeline());
}
std::atomic<int> pipelines{0};
};
class TestAcceptor : public Acceptor {
EventBase base_;
public:
TestAcceptor() : Acceptor(ServerSocketConfig()) {
Acceptor::init(nullptr, &base_);
}
void onNewConnection(
AsyncSocket::UniquePtr sock,
const folly::SocketAddress* address,
const std::string& nextProtocolName,
const TransportInfo& tinfo) {
}
};
class TestAcceptorFactory : public AcceptorFactory {
public:
std::shared_ptr<Acceptor> newAcceptor(EventBase* base) {
return std::make_shared<TestAcceptor>();
}
};
TEST(Bootstrap, Basic) {
TestServer server;
TestClient client;
}
TEST(Bootstrap, ServerWithPipeline) {
TestServer server;
server.childPipeline(std::make_shared<TestPipelineFactory>());
server.bind(0);
server.stop();
}
TEST(Bootstrap, ServerWithChildHandler) {
TestServer server;
server.childHandler(std::make_shared<TestAcceptorFactory>());
server.bind(0);
server.stop();
}
TEST(Bootstrap, ClientServerTest) {
TestServer server;
auto factory = std::make_shared<TestPipelineFactory>();
server.childPipeline(factory);
server.bind(0);
auto base = EventBaseManager::get()->getEventBase();
SocketAddress address;
server.getSockets()[0]->getAddress(&address);
TestClient client;
client.pipelineFactory(std::make_shared<TestClientPipelineFactory>());
client.connect(address);
base->loop();
server.stop();
CHECK(factory->pipelines == 1);
}
TEST(Bootstrap, ClientConnectionManagerTest) {
// Create a single IO thread, and verify that
// client connections are pooled properly
TestServer server;
auto factory = std::make_shared<TestPipelineFactory>();
server.childPipeline(factory);
server.group(std::make_shared<IOThreadPoolExecutor>(1));
server.bind(0);
auto base = EventBaseManager::get()->getEventBase();
SocketAddress address;
server.getSockets()[0]->getAddress(&address);
TestClient client;
client.pipelineFactory(std::make_shared<TestClientPipelineFactory>());
client.connect(address);
TestClient client2;
client2.pipelineFactory(std::make_shared<TestClientPipelineFactory>());
client2.connect(address);
base->loop();
server.stop();
CHECK(factory->pipelines == 2);
}
TEST(Bootstrap, ServerAcceptGroupTest) {
// Verify that server is using the accept IO group
TestServer server;
auto factory = std::make_shared<TestPipelineFactory>();
server.childPipeline(factory);
server.group(std::make_shared<IOThreadPoolExecutor>(1), nullptr);
server.bind(0);
SocketAddress address;
server.getSockets()[0]->getAddress(&address);
boost::barrier barrier(2);
auto thread = std::thread([&](){
TestClient client;
client.pipelineFactory(std::make_shared<TestClientPipelineFactory>());
client.connect(address);
EventBaseManager::get()->getEventBase()->loop();
barrier.wait();
});
barrier.wait();
server.stop();
thread.join();
CHECK(factory->pipelines == 1);
}
TEST(Bootstrap, ServerAcceptGroup2Test) {
// Verify that server is using the accept IO group
// Check if reuse port is supported, if not, don't run this test
try {
EventBase base;
auto serverSocket = AsyncServerSocket::newSocket(&base);
serverSocket->bind(0);
serverSocket->listen(0);
serverSocket->startAccepting();
serverSocket->setReusePortEnabled(true);
serverSocket->stopAccepting();
} catch(...) {
LOG(INFO) << "Reuse port probably not supported";
return;
}
TestServer server;
auto factory = std::make_shared<TestPipelineFactory>();
server.childPipeline(factory);
server.group(std::make_shared<IOThreadPoolExecutor>(4), nullptr);
server.bind(0);
SocketAddress address;
server.getSockets()[0]->getAddress(&address);
TestClient client;
client.pipelineFactory(std::make_shared<TestClientPipelineFactory>());
client.connect(address);
EventBaseManager::get()->getEventBase()->loop();
server.stop();
CHECK(factory->pipelines == 1);
}
TEST(Bootstrap, SharedThreadPool) {
// Check if reuse port is supported, if not, don't run this test
try {
EventBase base;
auto serverSocket = AsyncServerSocket::newSocket(&base);
serverSocket->bind(0);
serverSocket->listen(0);
serverSocket->startAccepting();
serverSocket->setReusePortEnabled(true);
serverSocket->stopAccepting();
} catch(...) {
LOG(INFO) << "Reuse port probably not supported";
return;
}
auto pool = std::make_shared<IOThreadPoolExecutor>(2);
TestServer server;
auto factory = std::make_shared<TestPipelineFactory>();
server.childPipeline(factory);
server.group(pool, pool);
server.bind(0);
SocketAddress address;
server.getSockets()[0]->getAddress(&address);
TestClient client;
client.pipelineFactory(std::make_shared<TestClientPipelineFactory>());
client.connect(address);
TestClient client2;
client2.pipelineFactory(std::make_shared<TestClientPipelineFactory>());
client2.connect(address);
TestClient client3;
client3.pipelineFactory(std::make_shared<TestClientPipelineFactory>());
client3.connect(address);
TestClient client4;
client4.pipelineFactory(std::make_shared<TestClientPipelineFactory>());
client4.connect(address);
TestClient client5;
client5.pipelineFactory(std::make_shared<TestClientPipelineFactory>());
client5.connect(address);
EventBaseManager::get()->getEventBase()->loop();
server.stop();
CHECK(factory->pipelines == 5);
}
TEST(Bootstrap, ExistingSocket) {
TestServer server;
auto factory = std::make_shared<TestPipelineFactory>();
server.childPipeline(factory);
folly::AsyncServerSocket::UniquePtr socket(new AsyncServerSocket);
server.bind(std::move(socket));
}
std::atomic<int> connections{0};
class TestHandlerPipeline : public InboundHandler<void*> {
public:
void read(Context* ctx, void* conn) {
connections++;
return ctx->fireRead(conn);
}
};
template <typename HandlerPipeline>
class TestHandlerPipelineFactory
: public PipelineFactory<ServerBootstrap<BytesPipeline>::AcceptPipeline> {
public:
std::unique_ptr<ServerBootstrap<BytesPipeline>::AcceptPipeline,
folly::DelayedDestruction::Destructor>
newPipeline(std::shared_ptr<AsyncSocket>) {
std::unique_ptr<ServerBootstrap<BytesPipeline>::AcceptPipeline,
folly::DelayedDestruction::Destructor> pipeline(
new ServerBootstrap<BytesPipeline>::AcceptPipeline);
pipeline->addBack(HandlerPipeline());
return pipeline;
}
};
TEST(Bootstrap, LoadBalanceHandler) {
TestServer server;
auto factory = std::make_shared<TestPipelineFactory>();
server.childPipeline(factory);
auto pipelinefactory =
std::make_shared<TestHandlerPipelineFactory<TestHandlerPipeline>>();
server.pipeline(pipelinefactory);
server.bind(0);
auto base = EventBaseManager::get()->getEventBase();
SocketAddress address;
server.getSockets()[0]->getAddress(&address);
TestClient client;
client.pipelineFactory(std::make_shared<TestClientPipelineFactory>());
client.connect(address);
base->loop();
server.stop();
CHECK(factory->pipelines == 1);
CHECK(connections == 1);
}
class TestUDPPipeline : public InboundHandler<void*> {
public:
void read(Context* ctx, void* conn) {
connections++;
}
};
TEST(Bootstrap, UDP) {
TestServer server;
auto factory = std::make_shared<TestPipelineFactory>();
auto pipelinefactory =
std::make_shared<TestHandlerPipelineFactory<TestUDPPipeline>>();
server.pipeline(pipelinefactory);
server.channelFactory(std::make_shared<AsyncUDPServerSocketFactory>());
server.bind(0);
}
TEST(Bootstrap, UDPClientServerTest) {
connections = 0;
TestServer server;
auto factory = std::make_shared<TestPipelineFactory>();
auto pipelinefactory =
std::make_shared<TestHandlerPipelineFactory<TestUDPPipeline>>();
server.pipeline(pipelinefactory);
server.channelFactory(std::make_shared<AsyncUDPServerSocketFactory>());
server.bind(0);
auto base = EventBaseManager::get()->getEventBase();
SocketAddress address;
server.getSockets()[0]->getAddress(&address);
SocketAddress localhost("::1", 0);
AsyncUDPSocket client(base);
client.bind(localhost);
auto data = IOBuf::create(1);
data->append(1);
*(data->writableData()) = 'a';
client.write(address, std::move(data));
base->loop();
server.stop();
CHECK(connections == 1);
}
folly/wangle/bootstrap/ClientBootstrap.h deleted 100644 → 0
View file @ a716b86b
/*
* Copyright 2015 Facebook, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#pragma once
#include <folly/wangle/channel/Pipeline.h>
#include <folly/wangle/concurrent/IOThreadPoolExecutor.h>
#include <folly/io/async/AsyncSocket.h>
#include <folly/io/async/EventBaseManager.h>
namespace folly {
/*
* A thin wrapper around Pipeline and AsyncSocket to match
* ServerBootstrap. On connect() a new pipeline is created.
*/
template <typename Pipeline>
class ClientBootstrap {
class ConnectCallback : public AsyncSocket::ConnectCallback {
public:
ConnectCallback(Promise<Pipeline*> promise, ClientBootstrap* bootstrap)
: promise_(std::move(promise))
, bootstrap_(bootstrap) {}
void connectSuccess() noexcept override {
if (bootstrap_->getPipeline()) {
bootstrap_->getPipeline()->transportActive();
}
promise_.setValue(bootstrap_->getPipeline());
delete this;
}
void connectErr(const AsyncSocketException& ex) noexcept override {
promise_.setException(
folly::make_exception_wrapper<AsyncSocketException>(ex));
delete this;
}
private:
Promise<Pipeline*> promise_;
ClientBootstrap* bootstrap_;
};
public:
ClientBootstrap() {
}
ClientBootstrap* group(
std::shared_ptr<folly::wangle::IOThreadPoolExecutor> group) {
group_ = group;
return this;
}
ClientBootstrap* bind(int port) {
port_ = port;
return this;
}
Future<Pipeline*> connect(SocketAddress address) {
DCHECK(pipelineFactory_);
auto base = EventBaseManager::get()->getEventBase();
if (group_) {
base = group_->getEventBase();
}
Future<Pipeline*> retval((Pipeline*)nullptr);
base->runImmediatelyOrRunInEventBaseThreadAndWait([&](){
auto socket = AsyncSocket::newSocket(base);
Promise<Pipeline*> promise;
retval = promise.getFuture();
socket->connect(
new ConnectCallback(std::move(promise), this), address);
pipeline_ = pipelineFactory_->newPipeline(socket);
});
return retval;
}
ClientBootstrap* pipelineFactory(
std::shared_ptr<PipelineFactory<Pipeline>> factory) {
pipelineFactory_ = factory;
return this;
}
Pipeline* getPipeline() {
return pipeline_.get();
}
virtual ~ClientBootstrap() {}
protected:
std::unique_ptr<Pipeline,
folly::DelayedDestruction::Destructor> pipeline_;
int port_;
std::shared_ptr<PipelineFactory<Pipeline>> pipelineFactory_;
std::shared_ptr<folly::wangle::IOThreadPoolExecutor> group_;
};
} // namespace
folly/wangle/bootstrap/ServerBootstrap-inl.h deleted 100644 → 0
View file @ a716b86b
/*
* Copyright 2015 Facebook, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#pragma once
#include <folly/wangle/acceptor/Acceptor.h>
#include <folly/wangle/bootstrap/ServerSocketFactory.h>
#include <folly/io/async/EventBaseManager.h>
#include <folly/wangle/concurrent/IOThreadPoolExecutor.h>
#include <folly/wangle/acceptor/ManagedConnection.h>
#include <folly/wangle/channel/Pipeline.h>
#include <folly/wangle/channel/Handler.h>
namespace folly {
template <typename Pipeline>
class ServerAcceptor
: public Acceptor
, public folly::wangle::InboundHandler<void*> {
typedef std::unique_ptr<Pipeline,
folly::DelayedDestruction::Destructor> PipelinePtr;
class ServerConnection : public wangle::ManagedConnection,
public wangle::PipelineManager {
public:
explicit ServerConnection(PipelinePtr pipeline)
: pipeline_(std::move(pipeline)) {
pipeline_->setPipelineManager(this);
}
~ServerConnection() {}
void timeoutExpired() noexcept override {
}
void describe(std::ostream& os) const override {}
bool isBusy() const override {
return false;
}
void notifyPendingShutdown() override {}
void closeWhenIdle() override {}
void dropConnection() override {
delete this;
}
void dumpConnectionState(uint8_t loglevel) override {}
void deletePipeline(wangle::PipelineBase* p) override {
CHECK(p == pipeline_.get());
delete this;
}
private:
PipelinePtr pipeline_;
};
public:
explicit ServerAcceptor(
std::shared_ptr<PipelineFactory<Pipeline>> pipelineFactory,
std::shared_ptr<folly::wangle::Pipeline<void*>> acceptorPipeline,
EventBase* base)
: Acceptor(ServerSocketConfig())
, base_(base)
, childPipelineFactory_(pipelineFactory)
, acceptorPipeline_(acceptorPipeline) {
Acceptor::init(nullptr, base_);
CHECK(acceptorPipeline_);
acceptorPipeline_->addBack(this);
acceptorPipeline_->finalize();
}
void read(Context* ctx, void* conn) {
AsyncSocket::UniquePtr transport((AsyncSocket*)conn);
std::unique_ptr<Pipeline,
folly::DelayedDestruction::Destructor>
pipeline(childPipelineFactory_->newPipeline(
std::shared_ptr<AsyncSocket>(
transport.release(),
folly::DelayedDestruction::Destructor())));
pipeline->transportActive();
auto connection = new ServerConnection(std::move(pipeline));
Acceptor::addConnection(connection);
}
/* See Acceptor::onNewConnection for details */
void onNewConnection(
AsyncSocket::UniquePtr transport, const SocketAddress* address,
const std::string& nextProtocolName, const TransportInfo& tinfo) {
acceptorPipeline_->read(transport.release());
}
// UDP thunk
void onDataAvailable(std::shared_ptr<AsyncUDPSocket> socket,
const folly::SocketAddress& addr,
std::unique_ptr<folly::IOBuf> buf,
bool truncated) noexcept {
acceptorPipeline_->read(buf.release());
}
private:
EventBase* base_;
std::shared_ptr<PipelineFactory<Pipeline>> childPipelineFactory_;
std::shared_ptr<folly::wangle::Pipeline<void*>> acceptorPipeline_;
};
template <typename Pipeline>
class ServerAcceptorFactory : public AcceptorFactory {
public:
explicit ServerAcceptorFactory(
std::shared_ptr<PipelineFactory<Pipeline>> factory,
std::shared_ptr<PipelineFactory<folly::wangle::Pipeline<void*>>> pipeline)
: factory_(factory)
, pipeline_(pipeline) {}
std::shared_ptr<Acceptor> newAcceptor(EventBase* base) {
std::shared_ptr<folly::wangle::Pipeline<void*>> pipeline(
pipeline_->newPipeline(nullptr));
return std::make_shared<ServerAcceptor<Pipeline>>(factory_, pipeline, base);
}
private:
std::shared_ptr<PipelineFactory<Pipeline>> factory_;
std::shared_ptr<PipelineFactory<
folly::wangle::Pipeline<void*>>> pipeline_;
};
class ServerWorkerPool : public folly::wangle::ThreadPoolExecutor::Observer {
public:
explicit ServerWorkerPool(
std::shared_ptr<AcceptorFactory> acceptorFactory,
folly::wangle::IOThreadPoolExecutor* exec,
std::shared_ptr<std::vector<std::shared_ptr<folly::AsyncSocketBase>>> sockets,
std::shared_ptr<ServerSocketFactory> socketFactory)
: acceptorFactory_(acceptorFactory)
, exec_(exec)
, sockets_(sockets)
, socketFactory_(socketFactory) {
CHECK(exec);
}
template <typename F>
void forEachWorker(F&& f) const;
void threadStarted(
folly::wangle::ThreadPoolExecutor::ThreadHandle*);
void threadStopped(
folly::wangle::ThreadPoolExecutor::ThreadHandle*);
void threadPreviouslyStarted(
folly::wangle::ThreadPoolExecutor::ThreadHandle* thread) {
threadStarted(thread);
}
void threadNotYetStopped(
folly::wangle::ThreadPoolExecutor::ThreadHandle* thread) {
threadStopped(thread);
}
private:
std::map<folly::wangle::ThreadPoolExecutor::ThreadHandle*,
std::shared_ptr<Acceptor>> workers_;
std::shared_ptr<AcceptorFactory> acceptorFactory_;
folly::wangle::IOThreadPoolExecutor* exec_{nullptr};
std::shared_ptr<std::vector<std::shared_ptr<folly::AsyncSocketBase>>> sockets_;
std::shared_ptr<ServerSocketFactory> socketFactory_;
};
template <typename F>
void ServerWorkerPool::forEachWorker(F&& f) const {
for (const auto& kv : workers_) {
f(kv.second.get());
}
}
class DefaultAcceptPipelineFactory
: public PipelineFactory<wangle::Pipeline<void*>> {
typedef wangle::Pipeline<void*> AcceptPipeline;
public:
std::unique_ptr<AcceptPipeline, folly::DelayedDestruction::Destructor>
newPipeline(std::shared_ptr<AsyncSocket>) {
return std::unique_ptr<AcceptPipeline, folly::DelayedDestruction::Destructor>
(new AcceptPipeline);
}
};
} // namespace
folly/wangle/bootstrap/ServerBootstrap.cpp deleted 100644 → 0
View file @ a716b86b
/*
* Copyright 2015 Facebook, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <folly/wangle/bootstrap/ServerBootstrap.h>
#include <folly/wangle/concurrent/NamedThreadFactory.h>
#include <folly/wangle/channel/Handler.h>
#include <folly/io/async/EventBaseManager.h>
namespace folly {
void ServerWorkerPool::threadStarted(
folly::wangle::ThreadPoolExecutor::ThreadHandle* h) {
auto worker = acceptorFactory_->newAcceptor(exec_->getEventBase(h));
workers_.insert({h, worker});
for(auto socket : *sockets_) {
socket->getEventBase()->runImmediatelyOrRunInEventBaseThreadAndWait(
[this, worker, socket](){
socketFactory_->addAcceptCB(
socket, worker.get(), worker->getEventBase());
});
}
}
void ServerWorkerPool::threadStopped(
folly::wangle::ThreadPoolExecutor::ThreadHandle* h) {
auto worker = workers_.find(h);
CHECK(worker != workers_.end());
for (auto socket : *sockets_) {
socket->getEventBase()->runImmediatelyOrRunInEventBaseThreadAndWait(
[&]() {
socketFactory_->removeAcceptCB(
socket, worker->second.get(), nullptr);
});
}
if (!worker->second->getEventBase()->isInEventBaseThread()) {
worker->second->getEventBase()->runImmediatelyOrRunInEventBaseThreadAndWait(
[=]() {
worker->second->dropAllConnections();
});
} else {
worker->second->dropAllConnections();
}
workers_.erase(worker);
}
} // namespace
folly/wangle/bootstrap/ServerBootstrap.h deleted 100644 → 0
View file @ a716b86b
/*
* Copyright 2015 Facebook, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#pragma once
#include <folly/wangle/bootstrap/ServerBootstrap-inl.h>
#include <folly/Baton.h>
#include <folly/wangle/channel/Pipeline.h>
namespace folly {
typedef folly::wangle::Pipeline<
folly::IOBufQueue&, std::unique_ptr<folly::IOBuf>> DefaultPipeline;
/*
* ServerBootstrap is a parent class intended to set up a
* high-performance TCP accepting server. It will manage a pool of
* accepting threads, any number of accepting sockets, a pool of
* IO-worker threads, and connection pool for each IO thread for you.
*
* The output is given as a Pipeline template: given a
* PipelineFactory, it will create a new pipeline for each connection,
* and your server can handle the incoming bytes.
*
* BACKWARDS COMPATIBLITY: for servers already taking a pool of
* Acceptor objects, an AcceptorFactory can be given directly instead
* of a pipeline factory.
*/
template <typename Pipeline>
class ServerBootstrap {
public:
ServerBootstrap(const ServerBootstrap& that) = delete;
ServerBootstrap(ServerBootstrap&& that) = default;
ServerBootstrap() {}
~ServerBootstrap() {
stop();
join();
}
typedef wangle::Pipeline<void*> AcceptPipeline;
/*
* Pipeline used to add connections to event bases.
* This is used for UDP or for load balancing
* TCP connections to IO threads explicitly
*/
ServerBootstrap* pipeline(
std::shared_ptr<PipelineFactory<AcceptPipeline>> factory) {
pipeline_ = factory;
return this;
}
ServerBootstrap* channelFactory(
std::shared_ptr<ServerSocketFactory> factory) {
socketFactory_ = factory;
return this;
}
/*
* BACKWARDS COMPATIBILITY - an acceptor factory can be set. Your
* Acceptor is responsible for managing the connection pool.
*
* @param childHandler - acceptor factory to call for each IO thread
*/
ServerBootstrap* childHandler(std::shared_ptr<AcceptorFactory> h) {
acceptorFactory_ = h;
return this;
}
/*
* Set a pipeline factory that will be called for each new connection
*
* @param factory pipeline factory to use for each new connection
*/
ServerBootstrap* childPipeline(
std::shared_ptr<PipelineFactory<Pipeline>> factory) {
childPipelineFactory_ = factory;
return this;
}
/*
* Set the IO executor. If not set, a default one will be created
* with one thread per core.
*
* @param io_group - io executor to use for IO threads.
*/
ServerBootstrap* group(
std::shared_ptr<folly::wangle::IOThreadPoolExecutor> io_group) {
return group(nullptr, io_group);
}
/*
* Set the acceptor executor, and IO executor.
*
* If no acceptor executor is set, a single thread will be created for accepts
* If no IO executor is set, a default of one thread per core will be created
*
* @param group - acceptor executor to use for acceptor threads.
* @param io_group - io executor to use for IO threads.
*/
ServerBootstrap* group(
std::shared_ptr<folly::wangle::IOThreadPoolExecutor> accept_group,
std::shared_ptr<wangle::IOThreadPoolExecutor> io_group) {
if (!accept_group) {
accept_group = std::make_shared<folly::wangle::IOThreadPoolExecutor>(
1, std::make_shared<wangle::NamedThreadFactory>("Acceptor Thread"));
}
if (!io_group) {
io_group = std::make_shared<folly::wangle::IOThreadPoolExecutor>(
32, std::make_shared<wangle::NamedThreadFactory>("IO Thread"));
}
// TODO better config checking
// CHECK(acceptorFactory_ || childPipelineFactory_);
CHECK(!(acceptorFactory_ && childPipelineFactory_));
if (acceptorFactory_) {
workerFactory_ = std::make_shared<ServerWorkerPool>(
acceptorFactory_, io_group.get(), sockets_, socketFactory_);
} else {
workerFactory_ = std::make_shared<ServerWorkerPool>(
std::make_shared<ServerAcceptorFactory<Pipeline>>(
childPipelineFactory_,
pipeline_),
io_group.get(), sockets_, socketFactory_);
}
io_group->addObserver(workerFactory_);
acceptor_group_ = accept_group;
io_group_ = io_group;
return this;
}
/*
* Bind to an existing socket
*
* @param sock Existing socket to use for accepting
*/
void bind(folly::AsyncServerSocket::UniquePtr s) {
if (!workerFactory_) {
group(nullptr);
}
// Since only a single socket is given,
// we can only accept on a single thread
CHECK(acceptor_group_->numThreads() == 1);
std::shared_ptr<folly::AsyncServerSocket> socket(
s.release(), DelayedDestruction::Destructor());
folly::Baton<> barrier;
acceptor_group_->add([&](){
socket->attachEventBase(EventBaseManager::get()->getEventBase());
socket->listen(socketConfig.acceptBacklog);
socket->startAccepting();
barrier.post();
});
barrier.wait();
// Startup all the threads
workerFactory_->forEachWorker([this, socket](Acceptor* worker){
socket->getEventBase()->runImmediatelyOrRunInEventBaseThreadAndWait(
[this, worker, socket](){
socketFactory_->addAcceptCB(socket, worker, worker->getEventBase());
});
});
sockets_->push_back(socket);
}
void bind(folly::SocketAddress& address) {
bindImpl(-1, address);
}
/*
* Bind to a port and start listening.
* One of childPipeline or childHandler must be called before bind
*
* @param port Port to listen on
*/
void bind(int port) {
CHECK(port >= 0);
folly::SocketAddress address;
bindImpl(port, address);
}
void bindImpl(int port, folly::SocketAddress& address) {
if (!workerFactory_) {
group(nullptr);
}
bool reusePort = false;
if (acceptor_group_->numThreads() > 1) {
reusePort = true;
}
std::mutex sock_lock;
std::vector<std::shared_ptr<folly::AsyncSocketBase>> new_sockets;
std::exception_ptr exn;
auto startupFunc = [&](std::shared_ptr<folly::Baton<>> barrier){
try {
auto socket = socketFactory_->newSocket(
port, address, socketConfig.acceptBacklog, reusePort, socketConfig);
sock_lock.lock();
new_sockets.push_back(socket);
sock_lock.unlock();
if (port <= 0) {
socket->getAddress(&address);
port = address.getPort();
}
barrier->post();
} catch (...) {
exn = std::current_exception();
barrier->post();
return;
}
};
auto wait0 = std::make_shared<folly::Baton<>>();
acceptor_group_->add(std::bind(startupFunc, wait0));
wait0->wait();
for (size_t i = 1; i < acceptor_group_->numThreads(); i++) {
auto barrier = std::make_shared<folly::Baton<>>();
acceptor_group_->add(std::bind(startupFunc, barrier));
barrier->wait();
}
if (exn) {
std::rethrow_exception(exn);
}
for (auto& socket : new_sockets) {
// Startup all the threads
workerFactory_->forEachWorker([this, socket](Acceptor* worker){
socket->getEventBase()->runImmediatelyOrRunInEventBaseThreadAndWait(
[this, worker, socket](){
socketFactory_->addAcceptCB(socket, worker, worker->getEventBase());
});
});
sockets_->push_back(socket);
}
}
/*
* Stop listening on all sockets.
*/
void stop() {
// sockets_ may be null if ServerBootstrap has been std::move'd
if (sockets_) {
for (auto socket : *sockets_) {
socket->getEventBase()->runImmediatelyOrRunInEventBaseThreadAndWait(
[&]() mutable {
socketFactory_->stopSocket(socket);
});
}
sockets_->clear();
}
if (!stopped_) {
stopped_ = true;
// stopBaton_ may be null if ServerBootstrap has been std::move'd
if (stopBaton_) {
stopBaton_->post();
}
}
}
void join() {
if (acceptor_group_) {
acceptor_group_->join();
}
if (io_group_) {
io_group_->join();
}
}
void waitForStop() {
if (!stopped_) {
CHECK(stopBaton_);
stopBaton_->wait();
}
}
/*
* Get the list of listening sockets
*/
const std::vector<std::shared_ptr<folly::AsyncSocketBase>>&
getSockets() const {
return *sockets_;
}
std::shared_ptr<wangle::IOThreadPoolExecutor> getIOGroup() const {
return io_group_;
}
template <typename F>
void forEachWorker(F&& f) const {
workerFactory_->forEachWorker(f);
}
ServerSocketConfig socketConfig;
private:
std::shared_ptr<wangle::IOThreadPoolExecutor> acceptor_group_;
std::shared_ptr<wangle::IOThreadPoolExecutor> io_group_;
std::shared_ptr<ServerWorkerPool> workerFactory_;
std::shared_ptr<std::vector<std::shared_ptr<folly::AsyncSocketBase>>> sockets_{
std::make_shared<std::vector<std::shared_ptr<folly::AsyncSocketBase>>>()};
std::shared_ptr<AcceptorFactory> acceptorFactory_;
std::shared_ptr<PipelineFactory<Pipeline>> childPipelineFactory_;
std::shared_ptr<PipelineFactory<AcceptPipeline>> pipeline_{
std::make_shared<DefaultAcceptPipelineFactory>()};
std::shared_ptr<ServerSocketFactory> socketFactory_{
std::make_shared<AsyncServerSocketFactory>()};
std::unique_ptr<folly::Baton<>> stopBaton_{
folly::make_unique<folly::Baton<>>()};
bool stopped_{false};
};
} // namespace
folly/wangle/bootstrap/ServerSocketFactory.h deleted 100644 → 0
View file @ a716b86b
/*
* Copyright 2015 Facebook, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#pragma once
#include <folly/wangle/bootstrap/ServerBootstrap-inl.h>
#include <folly/io/async/AsyncServerSocket.h>
#include <folly/io/async/EventBaseManager.h>
#include <folly/io/async/AsyncUDPServerSocket.h>
namespace folly {
class ServerSocketFactory {
public:
virtual std::shared_ptr<AsyncSocketBase> newSocket(
int port, SocketAddress address, int backlog,
bool reuse, ServerSocketConfig& config) = 0;
virtual void stopSocket(
std::shared_ptr<AsyncSocketBase>& socket) = 0;
virtual void removeAcceptCB(std::shared_ptr<AsyncSocketBase> sock, Acceptor *callback, EventBase* base) = 0;
virtual void addAcceptCB(std::shared_ptr<AsyncSocketBase> sock, Acceptor* callback, EventBase* base) = 0 ;
virtual ~ServerSocketFactory() = default;
};
class AsyncServerSocketFactory : public ServerSocketFactory {
public:
std::shared_ptr<AsyncSocketBase> newSocket(
int port, SocketAddress address, int backlog, bool reuse,
ServerSocketConfig& config) {
auto socket = folly::AsyncServerSocket::newSocket();
socket->setReusePortEnabled(reuse);
socket->attachEventBase(EventBaseManager::get()->getEventBase());
if (port >= 0) {
socket->bind(port);
} else {
socket->bind(address);
}
socket->listen(config.acceptBacklog);
socket->startAccepting();
return socket;
}
virtual void stopSocket(
std::shared_ptr<AsyncSocketBase>& s) {
auto socket = std::dynamic_pointer_cast<AsyncServerSocket>(s);
DCHECK(socket);
socket->stopAccepting();
socket->detachEventBase();
}
virtual void removeAcceptCB(std::shared_ptr<AsyncSocketBase> s,
Acceptor *callback, EventBase* base) {
auto socket = std::dynamic_pointer_cast<AsyncServerSocket>(s);
CHECK(socket);
socket->removeAcceptCallback(callback, base);
}
virtual void addAcceptCB(std::shared_ptr<AsyncSocketBase> s,
Acceptor* callback, EventBase* base) {
auto socket = std::dynamic_pointer_cast<AsyncServerSocket>(s);
CHECK(socket);
socket->addAcceptCallback(callback, base);
}
};
class AsyncUDPServerSocketFactory : public ServerSocketFactory {
public:
std::shared_ptr<AsyncSocketBase> newSocket(
int port, SocketAddress address, int backlog, bool reuse,
ServerSocketConfig& config) {
auto socket = std::make_shared<AsyncUDPServerSocket>(
EventBaseManager::get()->getEventBase());
socket->setReusePort(reuse);
if (port >= 0) {
SocketAddress addressr("::1", port);
socket->bind(addressr);
} else {
socket->bind(address);
}
socket->listen();
return socket;
}
virtual void stopSocket(
std::shared_ptr<AsyncSocketBase>& s) {
auto socket = std::dynamic_pointer_cast<AsyncUDPServerSocket>(s);
DCHECK(socket);
socket->close();
}
virtual void removeAcceptCB(std::shared_ptr<AsyncSocketBase> s,
Acceptor *callback, EventBase* base) {
}
virtual void addAcceptCB(std::shared_ptr<AsyncSocketBase> s,
Acceptor* callback, EventBase* base) {
auto socket = std::dynamic_pointer_cast<AsyncUDPServerSocket>(s);
DCHECK(socket);
socket->addListener(base, callback);
}
};
} // namespace
folly/wangle/channel/AsyncSocketHandler.h deleted 100644 → 0
View file @ a716b86b
/*
* Copyright 2015 Facebook, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#pragma once
#include <folly/wangle/channel/Handler.h>
#include <folly/io/async/AsyncSocket.h>
#include <folly/io/async/EventBase.h>
#include <folly/io/async/EventBaseManager.h>
#include <folly/io/IOBuf.h>
#include <folly/io/IOBufQueue.h>
namespace folly { namespace wangle {
// This handler may only be used in a single Pipeline
class AsyncSocketHandler
: public folly::wangle::BytesToBytesHandler,
public AsyncSocket::ReadCallback {
public:
explicit AsyncSocketHandler(
std::shared_ptr<AsyncSocket> socket)
: socket_(std::move(socket)) {}
AsyncSocketHandler(AsyncSocketHandler&&) = default;
~AsyncSocketHandler() {
detachReadCallback();
}
void attachReadCallback() {
socket_->setReadCB(socket_->good() ? this : nullptr);
}
void detachReadCallback() {
if (socket_ && socket_->getReadCallback() == this) {
socket_->setReadCB(nullptr);
}
auto ctx = getContext();
if (ctx && !firedInactive_) {
firedInactive_ = true;
ctx->fireTransportInactive();
}
}
void attachEventBase(folly::EventBase* eventBase) {
if (eventBase && !socket_->getEventBase()) {
socket_->attachEventBase(eventBase);
}
}
void detachEventBase() {
detachReadCallback();
if (socket_->getEventBase()) {
socket_->detachEventBase();
}
}
void transportActive(Context* ctx) override {
ctx->getPipeline()->setTransport(socket_);
attachReadCallback();
ctx->fireTransportActive();
}
void detachPipeline(Context* ctx) override {
detachReadCallback();
}
folly::Future<void> write(
Context* ctx,
std::unique_ptr<folly::IOBuf> buf) override {
if (UNLIKELY(!buf)) {
return folly::makeFuture();
}
if (!socket_->good()) {
VLOG(5) << "socket is closed in write()";
return folly::makeFuture<void>(AsyncSocketException(
AsyncSocketException::AsyncSocketExceptionType::NOT_OPEN,
"socket is closed in write()"));
}
auto cb = new WriteCallback();
auto future = cb->promise_.getFuture();
socket_->writeChain(cb, std::move(buf), ctx->getWriteFlags());
return future;
};
folly::Future<void> close(Context* ctx) override {
if (socket_) {
detachReadCallback();
socket_->closeNow();
}
ctx->getPipeline()->deletePipeline();
return folly::makeFuture();
}
// Must override to avoid warnings about hidden overloaded virtual due to
// AsyncSocket::ReadCallback::readEOF()
void readEOF(Context* ctx) override {
ctx->fireReadEOF();
}
void getReadBuffer(void** bufReturn, size_t* lenReturn) override {
const auto readBufferSettings = getContext()->getReadBufferSettings();
const auto ret = bufQueue_.preallocate(
readBufferSettings.first,
readBufferSettings.second);
*bufReturn = ret.first;
*lenReturn = ret.second;
}
void readDataAvailable(size_t len) noexcept override {
bufQueue_.postallocate(len);
getContext()->fireRead(bufQueue_);
}
void readEOF() noexcept override {
getContext()->fireReadEOF();
}
void readErr(const AsyncSocketException& ex)
noexcept override {
getContext()->fireReadException(
make_exception_wrapper<AsyncSocketException>(ex));
}
private:
class WriteCallback : private AsyncSocket::WriteCallback {
void writeSuccess() noexcept override {
promise_.setValue();
delete this;
}
void writeErr(size_t bytesWritten,
const AsyncSocketException& ex)
noexcept override {
promise_.setException(ex);
delete this;
}
private:
friend class AsyncSocketHandler;
folly::Promise<void> promise_;
};
folly::IOBufQueue bufQueue_{folly::IOBufQueue::cacheChainLength()};
std::shared_ptr<AsyncSocket> socket_{nullptr};
bool firedInactive_{false};
};
}}
folly/wangle/channel/EventBaseHandler.h deleted 100644 → 0
View file @ a716b86b
/*
* Copyright 2015 Facebook, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#pragma once
namespace folly { namespace wangle {
class EventBaseHandler : public OutboundBytesToBytesHandler {
public:
folly::Future<void> write(
Context* ctx,
std::unique_ptr<folly::IOBuf> buf) override {
folly::Future<void> retval;
DCHECK(ctx->getTransport());
DCHECK(ctx->getTransport()->getEventBase());
ctx->getTransport()->getEventBase()->runImmediatelyOrRunInEventBaseThreadAndWait([&](){
retval = ctx->fireWrite(std::move(buf));
});
return retval;
}
Future<void> close(Context* ctx) override {
DCHECK(ctx->getTransport());
DCHECK(ctx->getTransport()->getEventBase());
Future<void> retval;
ctx->getTransport()->getEventBase()->runImmediatelyOrRunInEventBaseThreadAndWait([&](){
retval = ctx->fireClose();
});
return retval;
}
};
}} // namespace
folly/wangle/channel/Handler.h deleted 100644 → 0
View file @ a716b86b
/*
* Copyright 2015 Facebook, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#pragma once
#include <folly/futures/Future.h>
#include <folly/wangle/channel/Pipeline.h>
#include <folly/io/IOBuf.h>
#include <folly/io/IOBufQueue.h>
namespace folly { namespace wangle {
template <class Context>
class HandlerBase {
public:
virtual ~HandlerBase() {}
virtual void attachPipeline(Context* ctx) {}
virtual void detachPipeline(Context* ctx) {}
Context* getContext() {
if (attachCount_ != 1) {
return nullptr;
}
CHECK(ctx_);
return ctx_;
}
private:
friend PipelineContext;
uint64_t attachCount_{0};
Context* ctx_{nullptr};
};
template <class Rin, class Rout = Rin, class Win = Rout, class Wout = Rin>
class Handler : public HandlerBase<HandlerContext<Rout, Wout>> {
public:
static const HandlerDir dir = HandlerDir::BOTH;
typedef Rin rin;
typedef Rout rout;
typedef Win win;
typedef Wout wout;
typedef HandlerContext<Rout, Wout> Context;
virtual ~Handler() {}
virtual void read(Context* ctx, Rin msg) = 0;
virtual void readEOF(Context* ctx) {
ctx->fireReadEOF();
}
virtual void readException(Context* ctx, exception_wrapper e) {
ctx->fireReadException(std::move(e));
}
virtual void transportActive(Context* ctx) {
ctx->fireTransportActive();
}
virtual void transportInactive(Context* ctx) {
ctx->fireTransportInactive();
}
virtual Future<void> write(Context* ctx, Win msg) = 0;
virtual Future<void> close(Context* ctx) {
return ctx->fireClose();
}
/*
// Other sorts of things we might want, all shamelessly stolen from Netty
// inbound
virtual void exceptionCaught(
HandlerContext* ctx,
exception_wrapper e) {}
virtual void channelRegistered(HandlerContext* ctx) {}
virtual void channelUnregistered(HandlerContext* ctx) {}
virtual void channelReadComplete(HandlerContext* ctx) {}
virtual void userEventTriggered(HandlerContext* ctx, void* evt) {}
virtual void channelWritabilityChanged(HandlerContext* ctx) {}
// outbound
virtual Future<void> bind(
HandlerContext* ctx,
SocketAddress localAddress) {}
virtual Future<void> connect(
HandlerContext* ctx,
SocketAddress remoteAddress, SocketAddress localAddress) {}
virtual Future<void> disconnect(HandlerContext* ctx) {}
virtual Future<void> deregister(HandlerContext* ctx) {}
virtual Future<void> read(HandlerContext* ctx) {}
virtual void flush(HandlerContext* ctx) {}
*/
};
template <class Rin, class Rout = Rin>
class InboundHandler : public HandlerBase<InboundHandlerContext<Rout>> {
public:
static const HandlerDir dir = HandlerDir::IN;
typedef Rin rin;
typedef Rout rout;
typedef Nothing win;
typedef Nothing wout;
typedef InboundHandlerContext<Rout> Context;
virtual ~InboundHandler() {}
virtual void read(Context* ctx, Rin msg) = 0;
virtual void readEOF(Context* ctx) {
ctx->fireReadEOF();
}
virtual void readException(Context* ctx, exception_wrapper e) {
ctx->fireReadException(std::move(e));
}
virtual void transportActive(Context* ctx) {
ctx->fireTransportActive();
}
virtual void transportInactive(Context* ctx) {
ctx->fireTransportInactive();
}
};
template <class Win, class Wout = Win>
class OutboundHandler : public HandlerBase<OutboundHandlerContext<Wout>> {
public:
static const HandlerDir dir = HandlerDir::OUT;
typedef Nothing rin;
typedef Nothing rout;
typedef Win win;
typedef Wout wout;
typedef OutboundHandlerContext<Wout> Context;
virtual ~OutboundHandler() {}
virtual Future<void> write(Context* ctx, Win msg) = 0;
virtual Future<void> close(Context* ctx) {
return ctx->fireClose();
}
};
template <class R, class W = R>
class HandlerAdapter : public Handler<R, R, W, W> {
public:
typedef typename Handler<R, R, W, W>::Context Context;
void read(Context* ctx, R msg) override {
ctx->fireRead(std::forward<R>(msg));
}
Future<void> write(Context* ctx, W msg) override {
return ctx->fireWrite(std::forward<W>(msg));
}
};
typedef HandlerAdapter<IOBufQueue&, std::unique_ptr<IOBuf>>
BytesToBytesHandler;
typedef InboundHandler<IOBufQueue&, std::unique_ptr<IOBuf>>
InboundBytesToBytesHandler;
typedef OutboundHandler<std::unique_ptr<IOBuf>>
OutboundBytesToBytesHandler;
}}
folly/wangle/channel/HandlerContext-inl.h deleted 100644 → 0
View file @ a716b86b
/*
* Copyright 2015 Facebook, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#pragma once
namespace folly { namespace wangle {
class PipelineContext {
public:
virtual ~PipelineContext() {}
virtual void attachPipeline() = 0;
virtual void detachPipeline() = 0;
template <class H, class HandlerContext>
void attachContext(H* handler, HandlerContext* ctx) {
if (++handler->attachCount_ == 1) {
handler->ctx_ = ctx;
} else {
handler->ctx_ = nullptr;
}
}
virtual void setNextIn(PipelineContext* ctx) = 0;
virtual void setNextOut(PipelineContext* ctx) = 0;
};
template <class In>
class InboundLink {
public:
virtual ~InboundLink() {}
virtual void read(In msg) = 0;
virtual void readEOF() = 0;
virtual void readException(exception_wrapper e) = 0;
virtual void transportActive() = 0;
virtual void transportInactive() = 0;
};
template <class Out>
class OutboundLink {
public:
virtual ~OutboundLink() {}
virtual Future<void> write(Out msg) = 0;
virtual Future<void> close() = 0;
};
template <class P, class H, class Context>
class ContextImplBase : public PipelineContext {
public:
~ContextImplBase() {}
H* getHandler() {
return handler_.get();
}
void initialize(P* pipeline, std::shared_ptr<H> handler) {
pipeline_ = pipeline;
handler_ = std::move(handler);
}
// PipelineContext overrides
void attachPipeline() override {
if (!attached_) {
this->attachContext(handler_.get(), impl_);
handler_->attachPipeline(impl_);
attached_ = true;
}
}
void detachPipeline() override {
handler_->detachPipeline(impl_);
attached_ = false;
}
void setNextIn(PipelineContext* ctx) override {
auto nextIn = dynamic_cast<InboundLink<typename H::rout>*>(ctx);
if (nextIn) {
nextIn_ = nextIn;
} else {
throw std::invalid_argument("inbound type mismatch");
}
}
void setNextOut(PipelineContext* ctx) override {
auto nextOut = dynamic_cast<OutboundLink<typename H::wout>*>(ctx);
if (nextOut) {
nextOut_ = nextOut;
} else {
throw std::invalid_argument("outbound type mismatch");
}
}
protected:
Context* impl_;
P* pipeline_;
std::shared_ptr<H> handler_;
InboundLink<typename H::rout>* nextIn_{nullptr};
OutboundLink<typename H::wout>* nextOut_{nullptr};
private:
bool attached_{false};
using DestructorGuard = typename P::DestructorGuard;
};
template <class P, class H>
class ContextImpl
: public HandlerContext<typename H::rout,
typename H::wout>,
public InboundLink<typename H::rin>,
public OutboundLink<typename H::win>,
public ContextImplBase<P, H, HandlerContext<typename H::rout,
typename H::wout>> {
public:
typedef typename H::rin Rin;
typedef typename H::rout Rout;
typedef typename H::win Win;
typedef typename H::wout Wout;
static const HandlerDir dir = HandlerDir::BOTH;
explicit ContextImpl(P* pipeline, std::shared_ptr<H> handler) {
this->impl_ = this;
this->initialize(pipeline, std::move(handler));
}
// For StaticPipeline
ContextImpl() {
this->impl_ = this;
}
~ContextImpl() {}
// HandlerContext overrides
void fireRead(Rout msg) override {
DestructorGuard dg(this->pipeline_);
if (this->nextIn_) {
this->nextIn_->read(std::forward<Rout>(msg));
} else {
LOG(WARNING) << "read reached end of pipeline";
}
}
void fireReadEOF() override {
DestructorGuard dg(this->pipeline_);
if (this->nextIn_) {
this->nextIn_->readEOF();
} else {
LOG(WARNING) << "readEOF reached end of pipeline";
}
}
void fireReadException(exception_wrapper e) override {
DestructorGuard dg(this->pipeline_);
if (this->nextIn_) {
this->nextIn_->readException(std::move(e));
} else {
LOG(WARNING) << "readException reached end of pipeline";
}
}
void fireTransportActive() override {
DestructorGuard dg(this->pipeline_);
if (this->nextIn_) {
this->nextIn_->transportActive();
}
}
void fireTransportInactive() override {
DestructorGuard dg(this->pipeline_);
if (this->nextIn_) {
this->nextIn_->transportInactive();
}
}
Future<void> fireWrite(Wout msg) override {
DestructorGuard dg(this->pipeline_);
if (this->nextOut_) {
return this->nextOut_->write(std::forward<Wout>(msg));
} else {
LOG(WARNING) << "write reached end of pipeline";
return makeFuture();
}
}
Future<void> fireClose() override {
DestructorGuard dg(this->pipeline_);
if (this->nextOut_) {
return this->nextOut_->close();
} else {
LOG(WARNING) << "close reached end of pipeline";
return makeFuture();
}
}
PipelineBase* getPipeline() override {
return this->pipeline_;
}
void setWriteFlags(WriteFlags flags) override {
this->pipeline_->setWriteFlags(flags);
}
WriteFlags getWriteFlags() override {
return this->pipeline_->getWriteFlags();
}
void setReadBufferSettings(
uint64_t minAvailable,
uint64_t allocationSize) override {
this->pipeline_->setReadBufferSettings(minAvailable, allocationSize);
}
std::pair<uint64_t, uint64_t> getReadBufferSettings() override {
return this->pipeline_->getReadBufferSettings();
}
// InboundLink overrides
void read(Rin msg) override {
DestructorGuard dg(this->pipeline_);
this->handler_->read(this, std::forward<Rin>(msg));
}
void readEOF() override {
DestructorGuard dg(this->pipeline_);
this->handler_->readEOF(this);
}
void readException(exception_wrapper e) override {
DestructorGuard dg(this->pipeline_);
this->handler_->readException(this, std::move(e));
}
void transportActive() override {
DestructorGuard dg(this->pipeline_);
this->handler_->transportActive(this);
}
void transportInactive() override {
DestructorGuard dg(this->pipeline_);
this->handler_->transportInactive(this);
}
// OutboundLink overrides
Future<void> write(Win msg) override {
DestructorGuard dg(this->pipeline_);
return this->handler_->write(this, std::forward<Win>(msg));
}
Future<void> close() override {
DestructorGuard dg(this->pipeline_);
return this->handler_->close(this);
}
private:
using DestructorGuard = typename P::DestructorGuard;
};
template <class P, class H>
class InboundContextImpl
: public InboundHandlerContext<typename H::rout>,
public InboundLink<typename H::rin>,
public ContextImplBase<P, H, InboundHandlerContext<typename H::rout>> {
public:
typedef typename H::rin Rin;
typedef typename H::rout Rout;
typedef typename H::win Win;
typedef typename H::wout Wout;
static const HandlerDir dir = HandlerDir::IN;
explicit InboundContextImpl(P* pipeline, std::shared_ptr<H> handler) {
this->impl_ = this;
this->initialize(pipeline, std::move(handler));
}
// For StaticPipeline
InboundContextImpl() {
this->impl_ = this;
}
~InboundContextImpl() {}
// InboundHandlerContext overrides
void fireRead(Rout msg) override {
DestructorGuard dg(this->pipeline_);
if (this->nextIn_) {
this->nextIn_->read(std::forward<Rout>(msg));
} else {
LOG(WARNING) << "read reached end of pipeline";
}
}
void fireReadEOF() override {
DestructorGuard dg(this->pipeline_);
if (this->nextIn_) {
this->nextIn_->readEOF();
} else {
LOG(WARNING) << "readEOF reached end of pipeline";
}
}
void fireReadException(exception_wrapper e) override {
DestructorGuard dg(this->pipeline_);
if (this->nextIn_) {
this->nextIn_->readException(std::move(e));
} else {
LOG(WARNING) << "readException reached end of pipeline";
}
}
void fireTransportActive() override {
DestructorGuard dg(this->pipeline_);
if (this->nextIn_) {
this->nextIn_->transportActive();
}
}
void fireTransportInactive() override {
DestructorGuard dg(this->pipeline_);
if (this->nextIn_) {
this->nextIn_->transportInactive();
}
}
PipelineBase* getPipeline() override {
return this->pipeline_;
}
// InboundLink overrides
void read(Rin msg) override {
DestructorGuard dg(this->pipeline_);
this->handler_->read(this, std::forward<Rin>(msg));
}
void readEOF() override {
DestructorGuard dg(this->pipeline_);
this->handler_->readEOF(this);
}
void readException(exception_wrapper e) override {
DestructorGuard dg(this->pipeline_);
this->handler_->readException(this, std::move(e));
}
void transportActive() override {
DestructorGuard dg(this->pipeline_);
this->handler_->transportActive(this);
}
void transportInactive() override {
DestructorGuard dg(this->pipeline_);
this->handler_->transportInactive(this);
}
private:
using DestructorGuard = typename P::DestructorGuard;
};
template <class P, class H>
class OutboundContextImpl
: public OutboundHandlerContext<typename H::wout>,
public OutboundLink<typename H::win>,
public ContextImplBase<P, H, OutboundHandlerContext<typename H::wout>> {
public:
typedef typename H::rin Rin;
typedef typename H::rout Rout;
typedef typename H::win Win;
typedef typename H::wout Wout;
static const HandlerDir dir = HandlerDir::OUT;
explicit OutboundContextImpl(P* pipeline, std::shared_ptr<H> handler) {
this->impl_ = this;
this->initialize(pipeline, std::move(handler));
}
// For StaticPipeline
OutboundContextImpl() {
this->impl_ = this;
}
~OutboundContextImpl() {}
// OutboundHandlerContext overrides
Future<void> fireWrite(Wout msg) override {
DestructorGuard dg(this->pipeline_);
if (this->nextOut_) {
return this->nextOut_->write(std::forward<Wout>(msg));
} else {
LOG(WARNING) << "write reached end of pipeline";
return makeFuture();
}
}
Future<void> fireClose() override {
DestructorGuard dg(this->pipeline_);
if (this->nextOut_) {
return this->nextOut_->close();
} else {
LOG(WARNING) << "close reached end of pipeline";
return makeFuture();
}
}
PipelineBase* getPipeline() override {
return this->pipeline_;
}
// OutboundLink overrides
Future<void> write(Win msg) override {
DestructorGuard dg(this->pipeline_);
return this->handler_->write(this, std::forward<Win>(msg));
}
Future<void> close() override {
DestructorGuard dg(this->pipeline_);
return this->handler_->close(this);
}
private:
using DestructorGuard = typename P::DestructorGuard;
};
template <class Handler, class Pipeline>
struct ContextType {
typedef typename std::conditional<
Handler::dir == HandlerDir::BOTH,
ContextImpl<Pipeline, Handler>,
typename std::conditional<
Handler::dir == HandlerDir::IN,
InboundContextImpl<Pipeline, Handler>,
OutboundContextImpl<Pipeline, Handler>
>::type>::type
type;
};
}} // folly::wangle
folly/wangle/channel/HandlerContext.h deleted 100644 → 0
View file @ a716b86b
/*
* Copyright 2015 Facebook, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#pragma once
#include <folly/io/async/AsyncTransport.h>
#include <folly/futures/Future.h>
#include <folly/ExceptionWrapper.h>
namespace folly { namespace wangle {
class PipelineBase;
template <class In, class Out>
class HandlerContext {
public:
virtual ~HandlerContext() {}
virtual void fireRead(In msg) = 0;
virtual void fireReadEOF() = 0;
virtual void fireReadException(exception_wrapper e) = 0;
virtual void fireTransportActive() = 0;
virtual void fireTransportInactive() = 0;
virtual Future<void> fireWrite(Out msg) = 0;
virtual Future<void> fireClose() = 0;
virtual PipelineBase* getPipeline() = 0;
std::shared_ptr<AsyncTransport> getTransport() {
return getPipeline()->getTransport();
}
virtual void setWriteFlags(WriteFlags flags) = 0;
virtual WriteFlags getWriteFlags() = 0;
virtual void setReadBufferSettings(
uint64_t minAvailable,
uint64_t allocationSize) = 0;
virtual std::pair<uint64_t, uint64_t> getReadBufferSettings() = 0;
/* TODO
template <class H>
virtual void addHandlerBefore(H&&) {}
template <class H>
virtual void addHandlerAfter(H&&) {}
template <class H>
virtual void replaceHandler(H&&) {}
virtual void removeHandler() {}
*/
};
template <class In>
class InboundHandlerContext {
public:
virtual ~InboundHandlerContext() {}
virtual void fireRead(In msg) = 0;
virtual void fireReadEOF() = 0;
virtual void fireReadException(exception_wrapper e) = 0;
virtual void fireTransportActive() = 0;
virtual void fireTransportInactive() = 0;
virtual PipelineBase* getPipeline() = 0;
std::shared_ptr<AsyncTransport> getTransport() {
return getPipeline()->getTransport();
}
// TODO Need get/set writeFlags, readBufferSettings? Probably not.
// Do we even really need them stored in the pipeline at all?
// Could just always delegate to the socket impl
};
template <class Out>
class OutboundHandlerContext {
public:
virtual ~OutboundHandlerContext() {}
virtual Future<void> fireWrite(Out msg) = 0;
virtual Future<void> fireClose() = 0;
virtual PipelineBase* getPipeline() = 0;
std::shared_ptr<AsyncTransport> getTransport() {
return getPipeline()->getTransport();
}
};
enum class HandlerDir {
IN,
OUT,
BOTH
};
}} // folly::wangle
#include <folly/wangle/channel/HandlerContext-inl.h>
folly/wangle/channel/OutputBufferingHandler.h deleted 100644 → 0
View file @ a716b86b
/*
* Copyright 2015 Facebook, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#pragma once
#include <folly/futures/SharedPromise.h>
#include <folly/wangle/channel/Handler.h>
#include <folly/io/async/EventBase.h>
#include <folly/io/async/EventBaseManager.h>
#include <folly/io/IOBuf.h>
#include <folly/io/IOBufQueue.h>
namespace folly { namespace wangle {
/*
* OutputBufferingHandler buffers writes in order to minimize syscalls. The
* transport will be written to once per event loop instead of on every write.
*
* This handler may only be used in a single Pipeline.
*/
class OutputBufferingHandler : public OutboundBytesToBytesHandler,
protected EventBase::LoopCallback {
public:
Future<void> write(Context* ctx, std::unique_ptr<IOBuf> buf) override {
CHECK(buf);
if (!queueSends_) {
return ctx->fireWrite(std::move(buf));
} else {
// Delay sends to optimize for fewer syscalls
if (!sends_) {
DCHECK(!isLoopCallbackScheduled());
// Buffer all the sends, and call writev once per event loop.
sends_ = std::move(buf);
ctx->getTransport()->getEventBase()->runInLoop(this);
} else {
DCHECK(isLoopCallbackScheduled());
sends_->prependChain(std::move(buf));
}
return sharedPromise_.getFuture();
}
}
void runLoopCallback() noexcept override {
MoveWrapper<SharedPromise<void>> sharedPromise;
std::swap(*sharedPromise, sharedPromise_);
getContext()->fireWrite(std::move(sends_))
.then([sharedPromise](Try<void> t) mutable {
sharedPromise->setTry(std::move(t));
});
}
Future<void> close(Context* ctx) override {
if (isLoopCallbackScheduled()) {
cancelLoopCallback();
}
// If there are sends queued, cancel them
sharedPromise_.setException(
folly::make_exception_wrapper<std::runtime_error>(
"close() called while sends still pending"));
sends_.reset();
sharedPromise_ = SharedPromise<void>();
return ctx->fireClose();
}
SharedPromise<void> sharedPromise_;
std::unique_ptr<IOBuf> sends_{nullptr};
bool queueSends_{true};
};
}}
folly/wangle/channel/Pipeline-inl.h deleted 100644 → 0
View file @ a716b86b
/*
* Copyright 2015 Facebook, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#pragma once
#include <glog/logging.h>
namespace folly { namespace wangle {
template <class R, class W>
Pipeline<R, W>::Pipeline() : isStatic_(false) {}
template <class R, class W>
Pipeline<R, W>::Pipeline(bool isStatic) : isStatic_(isStatic) {
CHECK(isStatic_);
}
template <class R, class W>
Pipeline<R, W>::~Pipeline() {
if (!isStatic_) {
detachHandlers();
}
}
template <class R, class W>
void Pipeline<R, W>::setWriteFlags(WriteFlags flags) {
writeFlags_ = flags;
}
template <class R, class W>
WriteFlags Pipeline<R, W>::getWriteFlags() {
return writeFlags_;
}
template <class R, class W>
void Pipeline<R, W>::setReadBufferSettings(
uint64_t minAvailable,
uint64_t allocationSize) {
readBufferSettings_ = std::make_pair(minAvailable, allocationSize);
}
template <class R, class W>
std::pair<uint64_t, uint64_t> Pipeline<R, W>::getReadBufferSettings() {
return readBufferSettings_;
}
template <class R, class W>
template <class T>
typename std::enable_if<!std::is_same<T, Nothing>::value>::type
Pipeline<R, W>::read(R msg) {
if (!front_) {
throw std::invalid_argument("read(): no inbound handler in Pipeline");
}
front_->read(std::forward<R>(msg));
}
template <class R, class W>
template <class T>
typename std::enable_if<!std::is_same<T, Nothing>::value>::type
Pipeline<R, W>::readEOF() {
if (!front_) {
throw std::invalid_argument("readEOF(): no inbound handler in Pipeline");
}
front_->readEOF();
}
template <class R, class W>
template <class T>
typename std::enable_if<!std::is_same<T, Nothing>::value>::type
Pipeline<R, W>::transportActive() {
if (front_) {
front_->transportActive();
}
}
template <class R, class W>
template <class T>
typename std::enable_if<!std::is_same<T, Nothing>::value>::type
Pipeline<R, W>::transportInactive() {
if (front_) {
front_->transportInactive();
}
}
template <class R, class W>
template <class T>
typename std::enable_if<!std::is_same<T, Nothing>::value>::type
Pipeline<R, W>::readException(exception_wrapper e) {
if (!front_) {
throw std::invalid_argument(
"readException(): no inbound handler in Pipeline");
}
front_->readException(std::move(e));
}
template <class R, class W>
template <class T>
typename std::enable_if<!std::is_same<T, Nothing>::value, Future<void>>::type
Pipeline<R, W>::write(W msg) {
if (!back_) {
throw std::invalid_argument("write(): no outbound handler in Pipeline");
}
return back_->write(std::forward<W>(msg));
}
template <class R, class W>
template <class T>
typename std::enable_if<!std::is_same<T, Nothing>::value, Future<void>>::type
Pipeline<R, W>::close() {
if (!back_) {
throw std::invalid_argument("close(): no outbound handler in Pipeline");
}
return back_->close();
}
template <class R, class W>
template <class H>
Pipeline<R, W>& Pipeline<R, W>::addBack(std::shared_ptr<H> handler) {
typedef typename ContextType<H, Pipeline<R, W>>::type Context;
return addHelper(std::make_shared<Context>(this, std::move(handler)), false);
}
template <class R, class W>
template <class H>
Pipeline<R, W>& Pipeline<R, W>::addBack(H&& handler) {
return addBack(std::make_shared<H>(std::forward<H>(handler)));
}
template <class R, class W>
template <class H>
Pipeline<R, W>& Pipeline<R, W>::addBack(H* handler) {
return addBack(std::shared_ptr<H>(handler, [](H*){}));
}
template <class R, class W>
template <class H>
Pipeline<R, W>& Pipeline<R, W>::addFront(std::shared_ptr<H> handler) {
typedef typename ContextType<H, Pipeline<R, W>>::type Context;
return addHelper(std::make_shared<Context>(this, std::move(handler)), true);
}
template <class R, class W>
template <class H>
Pipeline<R, W>& Pipeline<R, W>::addFront(H&& handler) {
return addFront(std::make_shared<H>(std::forward<H>(handler)));
}
template <class R, class W>
template <class H>
Pipeline<R, W>& Pipeline<R, W>::addFront(H* handler) {
return addFront(std::shared_ptr<H>(handler, [](H*){}));
}
template <class R, class W>
template <class H>
H* Pipeline<R, W>::getHandler(int i) {
typedef typename ContextType<H, Pipeline<R, W>>::type Context;
auto ctx = dynamic_cast<Context*>(ctxs_[i].get());
CHECK(ctx);
return ctx->getHandler();
}
namespace detail {
template <class T>
inline void logWarningIfNotNothing(const std::string& warning) {
LOG(WARNING) << warning;
}
template <>
inline void logWarningIfNotNothing<Nothing>(const std::string& warning) {
// do nothing
}
} // detail
// TODO Have read/write/etc check that pipeline has been finalized
template <class R, class W>
void Pipeline<R, W>::finalize() {
if (!inCtxs_.empty()) {
front_ = dynamic_cast<InboundLink<R>*>(inCtxs_.front());
for (size_t i = 0; i < inCtxs_.size() - 1; i++) {
inCtxs_[i]->setNextIn(inCtxs_[i+1]);
}
}
if (!outCtxs_.empty()) {
back_ = dynamic_cast<OutboundLink<W>*>(outCtxs_.back());
for (size_t i = outCtxs_.size() - 1; i > 0; i--) {
outCtxs_[i]->setNextOut(outCtxs_[i-1]);
}
}
if (!front_) {
detail::logWarningIfNotNothing<R>(
"No inbound handler in Pipeline, inbound operations will throw "
"std::invalid_argument");
}
if (!back_) {
detail::logWarningIfNotNothing<W>(
"No outbound handler in Pipeline, outbound operations will throw "
"std::invalid_argument");
}
for (auto it = ctxs_.rbegin(); it != ctxs_.rend(); it++) {
(*it)->attachPipeline();
}
}
template <class R, class W>
template <class H>
bool Pipeline<R, W>::setOwner(H* handler) {
typedef typename ContextType<H, Pipeline<R, W>>::type Context;
for (auto& ctx : ctxs_) {
auto ctxImpl = dynamic_cast<Context*>(ctx.get());
if (ctxImpl && ctxImpl->getHandler() == handler) {
owner_ = ctx;
return true;
}
}
return false;
}
template <class R, class W>
template <class Context>
void Pipeline<R, W>::addContextFront(Context* ctx) {
addHelper(std::shared_ptr<Context>(ctx, [](Context*){}), true);
}
template <class R, class W>
void Pipeline<R, W>::detachHandlers() {
for (auto& ctx : ctxs_) {
if (ctx != owner_) {
ctx->detachPipeline();
}
}
}
template <class R, class W>
template <class Context>
Pipeline<R, W>& Pipeline<R, W>::addHelper(
std::shared_ptr<Context>&& ctx,
bool front) {
ctxs_.insert(front ? ctxs_.begin() : ctxs_.end(), ctx);
if (Context::dir == HandlerDir::BOTH || Context::dir == HandlerDir::IN) {
inCtxs_.insert(front ? inCtxs_.begin() : inCtxs_.end(), ctx.get());
}
if (Context::dir == HandlerDir::BOTH || Context::dir == HandlerDir::OUT) {
outCtxs_.insert(front ? outCtxs_.begin() : outCtxs_.end(), ctx.get());
}
return *this;
}
}} // folly::wangle
folly/wangle/channel/Pipeline.h deleted 100644 → 0
View file @ a716b86b
/*
* Copyright 2015 Facebook, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#pragma once
#include <folly/wangle/channel/HandlerContext.h>
#include <folly/futures/Future.h>
#include <folly/io/async/AsyncTransport.h>
#include <folly/io/async/DelayedDestruction.h>
#include <folly/ExceptionWrapper.h>
#include <folly/Memory.h>
namespace folly { namespace wangle {
class PipelineManager {
public:
virtual ~PipelineManager() {}
virtual void deletePipeline(PipelineBase* pipeline) = 0;
};
class PipelineBase {
public:
virtual ~PipelineBase() {}
void setPipelineManager(PipelineManager* manager) {
manager_ = manager;
}
void deletePipeline() {
if (manager_) {
manager_->deletePipeline(this);
}
}
void setTransport(std::shared_ptr<AsyncTransport> transport) {
transport_ = transport;
}
std::shared_ptr<AsyncTransport> getTransport() {
return transport_;
}
private:
PipelineManager* manager_{nullptr};
std::shared_ptr<AsyncTransport> transport_;
};
struct Nothing{};
/*
* R is the inbound type, i.e. inbound calls start with pipeline.read(R)
* W is the outbound type, i.e. outbound calls start with pipeline.write(W)
*
* Use Nothing for one of the types if your pipeline is unidirectional.
* If R is Nothing, read(), readEOF(), and readException() will be disabled.
* If W is Nothing, write() and close() will be disabled.
*/
template <class R, class W = Nothing>
class Pipeline : public PipelineBase, public DelayedDestruction {
public:
Pipeline();
~Pipeline();
void setWriteFlags(WriteFlags flags);
WriteFlags getWriteFlags();
void setReadBufferSettings(uint64_t minAvailable, uint64_t allocationSize);
std::pair<uint64_t, uint64_t> getReadBufferSettings();
template <class T = R>
typename std::enable_if<!std::is_same<T, Nothing>::value>::type
read(R msg);
template <class T = R>
typename std::enable_if<!std::is_same<T, Nothing>::value>::type
readEOF();
template <class T = R>
typename std::enable_if<!std::is_same<T, Nothing>::value>::type
readException(exception_wrapper e);
template <class T = R>
typename std::enable_if<!std::is_same<T, Nothing>::value>::type
transportActive();
template <class T = R>
typename std::enable_if<!std::is_same<T, Nothing>::value>::type
transportInactive();
template <class T = W>
typename std::enable_if<!std::is_same<T, Nothing>::value, Future<void>>::type
write(W msg);
template <class T = W>
typename std::enable_if<!std::is_same<T, Nothing>::value, Future<void>>::type
close();
template <class H>
Pipeline& addBack(std::shared_ptr<H> handler);
template <class H>
Pipeline& addBack(H&& handler);
template <class H>
Pipeline& addBack(H* handler);
template <class H>
Pipeline& addFront(std::shared_ptr<H> handler);
template <class H>
Pipeline& addFront(H&& handler);
template <class H>
Pipeline& addFront(H* handler);
template <class H>
H* getHandler(int i);
void finalize();
// If one of the handlers owns the pipeline itself, use setOwner to ensure
// that the pipeline doesn't try to detach the handler during destruction,
// lest destruction ordering issues occur.
// See thrift/lib/cpp2/async/Cpp2Channel.cpp for an example
template <class H>
bool setOwner(H* handler);
protected:
explicit Pipeline(bool isStatic);
template <class Context>
void addContextFront(Context* ctx);
void detachHandlers();
private:
template <class Context>
Pipeline& addHelper(std::shared_ptr<Context>&& ctx, bool front);
WriteFlags writeFlags_{WriteFlags::NONE};
std::pair<uint64_t, uint64_t> readBufferSettings_{2048, 2048};
bool isStatic_{false};
std::shared_ptr<PipelineContext> owner_;
std::vector<std::shared_ptr<PipelineContext>> ctxs_;
std::vector<PipelineContext*> inCtxs_;
std::vector<PipelineContext*> outCtxs_;
InboundLink<R>* front_{nullptr};
OutboundLink<W>* back_{nullptr};
};
}}
namespace folly {
class AsyncSocket;
template <typename Pipeline>
class PipelineFactory {
public:
virtual std::unique_ptr<Pipeline, folly::DelayedDestruction::Destructor>
newPipeline(std::shared_ptr<AsyncSocket>) = 0;
virtual ~PipelineFactory() {}
};
}
#include <folly/wangle/channel/Pipeline-inl.h>
folly/wangle/channel/StaticPipeline.h deleted 100644 → 0
View file @ a716b86b
/*
* Copyright 2015 Facebook, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#pragma once
#include <type_traits>
#include <folly/wangle/channel/Pipeline.h>
namespace folly { namespace wangle {
/*
* StaticPipeline allows you to create a Pipeline with minimal allocations.
* Specify your handlers after the input/output types of your Pipeline in order
* from front to back, and construct with either H&&, H*, or std::shared_ptr<H>
* for each handler. The pipeline will be finalized for you at the end of
* construction. For example:
*
* StringToStringHandler stringHandler1;
* auto stringHandler2 = std::make_shared<StringToStringHandler>();
*
* StaticPipeline<int, std::string,
* IntToStringHandler,
* StringToStringHandler,
* StringToStringHandler>(
* IntToStringHandler(), // H&&
* &stringHandler1, // H*
* stringHandler2) // std::shared_ptr<H>
* pipeline;
*
* You can then use pipeline just like any Pipeline. See Pipeline.h.
*/
template <class R, class W, class... Handlers>
class StaticPipeline;
template <class R, class W>
class StaticPipeline<R, W> : public Pipeline<R, W> {
protected:
explicit StaticPipeline(bool) : Pipeline<R, W>(true) {}
};
template <class Handler>
class BaseWithOptional {
protected:
folly::Optional<Handler> handler_;
};
template <class Handler>
class BaseWithoutOptional {
};
template <class R, class W, class Handler, class... Handlers>
class StaticPipeline<R, W, Handler, Handlers...>
: public StaticPipeline<R, W, Handlers...>
, public std::conditional<std::is_abstract<Handler>::value,
BaseWithoutOptional<Handler>,
BaseWithOptional<Handler>>::type {
public:
template <class... HandlerArgs>
explicit StaticPipeline(HandlerArgs&&... handlers)
: StaticPipeline(true, std::forward<HandlerArgs>(handlers)...) {
isFirst_ = true;
}
~StaticPipeline() {
if (isFirst_) {
Pipeline<R, W>::detachHandlers();
}
}
protected:
template <class HandlerArg, class... HandlerArgs>
StaticPipeline(
bool isFirst,
HandlerArg&& handler,
HandlerArgs&&... handlers)
: StaticPipeline<R, W, Handlers...>(
false,
std::forward<HandlerArgs>(handlers)...) {
isFirst_ = isFirst;
setHandler(std::forward<HandlerArg>(handler));
CHECK(handlerPtr_);
ctx_.initialize(this, handlerPtr_);
Pipeline<R, W>::addContextFront(&ctx_);
if (isFirst_) {
Pipeline<R, W>::finalize();
}
}
private:
template <class HandlerArg>
typename std::enable_if<std::is_same<
typename std::remove_reference<HandlerArg>::type,
Handler
>::value>::type
setHandler(HandlerArg&& arg) {
BaseWithOptional<Handler>::handler_.emplace(std::forward<HandlerArg>(arg));
handlerPtr_ = std::shared_ptr<Handler>(&(*BaseWithOptional<Handler>::handler_), [](Handler*){});
}
template <class HandlerArg>
typename std::enable_if<std::is_same<
typename std::decay<HandlerArg>::type,
std::shared_ptr<Handler>
>::value>::type
setHandler(HandlerArg&& arg) {
handlerPtr_ = std::forward<HandlerArg>(arg);
}
template <class HandlerArg>
typename std::enable_if<std::is_same<
typename std::decay<HandlerArg>::type,
Handler*
>::value>::type
setHandler(HandlerArg&& arg) {
handlerPtr_ = std::shared_ptr<Handler>(arg, [](Handler*){});
}
bool isFirst_;
std::shared_ptr<Handler> handlerPtr_;
typename ContextType<Handler, Pipeline<R, W>>::type ctx_;
};
}} // folly::wangle
folly/wangle/channel/test/MockHandler.h deleted 100644 → 0
View file @ a716b86b
/*
* Copyright 2015 Facebook, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#pragma once
#include <folly/wangle/channel/Handler.h>
#include <gmock/gmock.h>
namespace folly { namespace wangle {
template <class Rin, class Rout = Rin, class Win = Rout, class Wout = Rin>
class MockHandler : public Handler<Rin, Rout, Win, Wout> {
public:
typedef typename Handler<Rin, Rout, Win, Wout>::Context Context;
MockHandler() = default;
MockHandler(MockHandler&&) = default;
#ifdef __clang__
# pragma clang diagnostic push
# if __clang_major__ > 3 || __clang_minor__ >= 6
# pragma clang diagnostic ignored "-Winconsistent-missing-override"
# endif
#endif
MOCK_METHOD2_T(read_, void(Context*, Rin&));
MOCK_METHOD1_T(readEOF, void(Context*));
MOCK_METHOD2_T(readException, void(Context*, exception_wrapper));
MOCK_METHOD2_T(write_, void(Context*, Win&));
MOCK_METHOD1_T(close_, void(Context*));
MOCK_METHOD1_T(attachPipeline, void(Context*));
MOCK_METHOD1_T(attachTransport, void(Context*));
MOCK_METHOD1_T(detachPipeline, void(Context*));
MOCK_METHOD1_T(detachTransport, void(Context*));
#ifdef __clang__
#pragma clang diagnostic pop
#endif
void read(Context* ctx, Rin msg) override {
read_(ctx, msg);
}
Future<void> write(Context* ctx, Win msg) override {
return makeFutureWith([&](){
write_(ctx, msg);
});
}
Future<void> close(Context* ctx) override {
return makeFutureWith([&](){
close_(ctx);
});
}
};
template <class R, class W = R>
using MockHandlerAdapter = MockHandler<R, R, W, W>;
}}
folly/wangle/channel/test/OutputBufferingHandlerTest.cpp deleted 100644 → 0
View file @ a716b86b
/*
* Copyright 2015 Facebook, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <folly/wangle/channel/StaticPipeline.h>
#include <folly/wangle/channel/OutputBufferingHandler.h>
#include <folly/wangle/channel/test/MockHandler.h>
#include <folly/io/async/AsyncSocket.h>
#include <gmock/gmock.h>
#include <gtest/gtest.h>
using namespace folly;
using namespace folly::wangle;
using namespace testing;
typedef StrictMock<MockHandlerAdapter<
IOBufQueue&,
std::unique_ptr<IOBuf>>>
MockBytesHandler;
MATCHER_P(IOBufContains, str, "") { return arg->moveToFbString() == str; }
TEST(OutputBufferingHandlerTest, Basic) {
MockBytesHandler mockHandler;
EXPECT_CALL(mockHandler, attachPipeline(_));
StaticPipeline<IOBufQueue&, std::unique_ptr<IOBuf>,
MockBytesHandler,
OutputBufferingHandler>
pipeline(&mockHandler, OutputBufferingHandler{});
EventBase eb;
auto socket = AsyncSocket::newSocket(&eb);
pipeline.setTransport(socket);
// Buffering should prevent writes until the EB loops, and the writes should
// be batched into one write call.
auto f1 = pipeline.write(IOBuf::copyBuffer("hello"));
auto f2 = pipeline.write(IOBuf::copyBuffer("world"));
EXPECT_FALSE(f1.isReady());
EXPECT_FALSE(f2.isReady());
EXPECT_CALL(mockHandler, write_(_, IOBufContains("helloworld")));
eb.loopOnce();
EXPECT_TRUE(f1.isReady());
EXPECT_TRUE(f2.isReady());
EXPECT_CALL(mockHandler, detachPipeline(_));
// Make sure the SharedPromise resets correctly
auto f = pipeline.write(IOBuf::copyBuffer("foo"));
EXPECT_FALSE(f.isReady());
EXPECT_CALL(mockHandler, write_(_, IOBufContains("foo")));
eb.loopOnce();
EXPECT_TRUE(f.isReady());
}
folly/wangle/channel/test/PipelineTest.cpp deleted 100644 → 0
View file @ a716b86b
/*
* Copyright 2015 Facebook, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <folly/wangle/channel/Handler.h>
#include <folly/wangle/channel/Pipeline.h>
#include <folly/wangle/channel/StaticPipeline.h>
#include <folly/wangle/channel/AsyncSocketHandler.h>
#include <folly/wangle/channel/OutputBufferingHandler.h>
#include <folly/wangle/channel/test/MockHandler.h>
#include <gmock/gmock.h>
#include <gtest/gtest.h>
using namespace folly;
using namespace folly::wangle;
using namespace testing;
typedef StrictMock<MockHandlerAdapter<int, int>> IntHandler;
class IntHandler2 : public StrictMock<MockHandlerAdapter<int, int>> {};
ACTION(FireRead) {
arg0->fireRead(arg1);
}
ACTION(FireReadEOF) {
arg0->fireReadEOF();
}
ACTION(FireReadException) {
arg0->fireReadException(arg1);
}
ACTION(FireWrite) {
arg0->fireWrite(arg1);
}
ACTION(FireClose) {
arg0->fireClose();
}
// Test move only types, among other things
TEST(PipelineTest, RealHandlersCompile) {
EventBase eb;
auto socket = AsyncSocket::newSocket(&eb);
// static
{
StaticPipeline<IOBufQueue&, std::unique_ptr<IOBuf>,
AsyncSocketHandler,
OutputBufferingHandler>
pipeline{AsyncSocketHandler(socket), OutputBufferingHandler()};
EXPECT_TRUE(pipeline.getHandler<AsyncSocketHandler>(0));
EXPECT_TRUE(pipeline.getHandler<OutputBufferingHandler>(1));
}
// dynamic
{
Pipeline<IOBufQueue&, std::unique_ptr<IOBuf>> pipeline;
pipeline
.addBack(AsyncSocketHandler(socket))
.addBack(OutputBufferingHandler())
.finalize();
EXPECT_TRUE(pipeline.getHandler<AsyncSocketHandler>(0));
EXPECT_TRUE(pipeline.getHandler<OutputBufferingHandler>(1));
}
}
// Test that handlers correctly fire the next handler when directed
TEST(PipelineTest, FireActions) {
IntHandler handler1;
IntHandler2 handler2;
{
InSequence sequence;
EXPECT_CALL(handler2, attachPipeline(_));
EXPECT_CALL(handler1, attachPipeline(_));
}
StaticPipeline<int, int, IntHandler, IntHandler2>
pipeline(&handler1, &handler2);
EXPECT_CALL(handler1, read_(_, _)).WillOnce(FireRead());
EXPECT_CALL(handler2, read_(_, _)).Times(1);
pipeline.read(1);
EXPECT_CALL(handler1, readEOF(_)).WillOnce(FireReadEOF());
EXPECT_CALL(handler2, readEOF(_)).Times(1);
pipeline.readEOF();
EXPECT_CALL(handler1, readException(_, _)).WillOnce(FireReadException());
EXPECT_CALL(handler2, readException(_, _)).Times(1);
pipeline.readException(make_exception_wrapper<std::runtime_error>("blah"));
EXPECT_CALL(handler2, write_(_, _)).WillOnce(FireWrite());
EXPECT_CALL(handler1, write_(_, _)).Times(1);
EXPECT_NO_THROW(pipeline.write(1).value());
EXPECT_CALL(handler2, close_(_)).WillOnce(FireClose());
EXPECT_CALL(handler1, close_(_)).Times(1);
EXPECT_NO_THROW(pipeline.close().value());
{
InSequence sequence;
EXPECT_CALL(handler1, detachPipeline(_));
EXPECT_CALL(handler2, detachPipeline(_));
}
}
// Test that nothing bad happens when actions reach the end of the pipeline
// (a warning will be logged, however)
TEST(PipelineTest, ReachEndOfPipeline) {
IntHandler handler;
EXPECT_CALL(handler, attachPipeline(_));
StaticPipeline<int, int, IntHandler>
pipeline(&handler);
EXPECT_CALL(handler, read_(_, _)).WillOnce(FireRead());
pipeline.read(1);
EXPECT_CALL(handler, readEOF(_)).WillOnce(FireReadEOF());
pipeline.readEOF();
EXPECT_CALL(handler, readException(_, _)).WillOnce(FireReadException());
pipeline.readException(make_exception_wrapper<std::runtime_error>("blah"));
EXPECT_CALL(handler, write_(_, _)).WillOnce(FireWrite());
EXPECT_NO_THROW(pipeline.write(1).value());
EXPECT_CALL(handler, close_(_)).WillOnce(FireClose());
EXPECT_NO_THROW(pipeline.close().value());
EXPECT_CALL(handler, detachPipeline(_));
}
// Test having the last read handler turn around and write
TEST(PipelineTest, TurnAround) {
IntHandler handler1;
IntHandler2 handler2;
{
InSequence sequence;
EXPECT_CALL(handler2, attachPipeline(_));
EXPECT_CALL(handler1, attachPipeline(_));
}
StaticPipeline<int, int, IntHandler, IntHandler2>
pipeline(&handler1, &handler2);
EXPECT_CALL(handler1, read_(_, _)).WillOnce(FireRead());
EXPECT_CALL(handler2, read_(_, _)).WillOnce(FireWrite());
EXPECT_CALL(handler1, write_(_, _)).Times(1);
pipeline.read(1);
{
InSequence sequence;
EXPECT_CALL(handler1, detachPipeline(_));
EXPECT_CALL(handler2, detachPipeline(_));
}
}
TEST(PipelineTest, DynamicFireActions) {
IntHandler handler1, handler2, handler3;
EXPECT_CALL(handler2, attachPipeline(_));
StaticPipeline<int, int, IntHandler>
pipeline(&handler2);
{
InSequence sequence;
EXPECT_CALL(handler3, attachPipeline(_));
EXPECT_CALL(handler1, attachPipeline(_));
}
pipeline
.addFront(&handler1)
.addBack(&handler3)
.finalize();
EXPECT_TRUE(pipeline.getHandler<IntHandler>(0));
EXPECT_TRUE(pipeline.getHandler<IntHandler>(1));
EXPECT_TRUE(pipeline.getHandler<IntHandler>(2));
EXPECT_CALL(handler1, read_(_, _)).WillOnce(FireRead());
EXPECT_CALL(handler2, read_(_, _)).WillOnce(FireRead());
EXPECT_CALL(handler3, read_(_, _)).Times(1);
pipeline.read(1);
EXPECT_CALL(handler3, write_(_, _)).WillOnce(FireWrite());
EXPECT_CALL(handler2, write_(_, _)).WillOnce(FireWrite());
EXPECT_CALL(handler1, write_(_, _)).Times(1);
EXPECT_NO_THROW(pipeline.write(1).value());
{
InSequence sequence;
EXPECT_CALL(handler1, detachPipeline(_));
EXPECT_CALL(handler2, detachPipeline(_));
EXPECT_CALL(handler3, detachPipeline(_));
}
}
TEST(PipelineTest, DynamicAttachDetachOrder) {
IntHandler handler1, handler2;
Pipeline<int, int> pipeline;
{
InSequence sequence;
EXPECT_CALL(handler2, attachPipeline(_));
EXPECT_CALL(handler1, attachPipeline(_));
}
pipeline
.addBack(&handler1)
.addBack(&handler2)
.finalize();
{
InSequence sequence;
EXPECT_CALL(handler1, detachPipeline(_));
EXPECT_CALL(handler2, detachPipeline(_));
}
}
TEST(PipelineTest, GetContext) {
IntHandler handler;
EXPECT_CALL(handler, attachPipeline(_));
StaticPipeline<int, int, IntHandler> pipeline(&handler);
EXPECT_TRUE(handler.getContext());
EXPECT_CALL(handler, detachPipeline(_));
}
TEST(PipelineTest, HandlerInMultiplePipelines) {
IntHandler handler;
EXPECT_CALL(handler, attachPipeline(_)).Times(2);
StaticPipeline<int, int, IntHandler> pipeline1(&handler);
StaticPipeline<int, int, IntHandler> pipeline2(&handler);
EXPECT_FALSE(handler.getContext());
EXPECT_CALL(handler, detachPipeline(_)).Times(2);
}
TEST(PipelineTest, HandlerInPipelineTwice) {
auto handler = std::make_shared<IntHandler>();
EXPECT_CALL(*handler, attachPipeline(_)).Times(2);
Pipeline<int, int> pipeline;
pipeline.addBack(handler);
pipeline.addBack(handler);
pipeline.finalize();
EXPECT_FALSE(handler->getContext());
EXPECT_CALL(*handler, detachPipeline(_)).Times(2);
}
TEST(PipelineTest, NoDetachOnOwner) {
IntHandler handler;
EXPECT_CALL(handler, attachPipeline(_));
StaticPipeline<int, int, IntHandler> pipeline(&handler);
pipeline.setOwner(&handler);
}
template <class Rin, class Rout = Rin, class Win = Rout, class Wout = Rin>
class ConcreteHandler : public Handler<Rin, Rout, Win, Wout> {
typedef typename Handler<Rin, Rout, Win, Wout>::Context Context;
public:
void read(Context* ctx, Rin msg) {}
Future<void> write(Context* ctx, Win msg) { return makeFuture(); }
};
typedef HandlerAdapter<std::string, std::string> StringHandler;
typedef ConcreteHandler<int, std::string> IntToStringHandler;
typedef ConcreteHandler<std::string, int> StringToIntHandler;
TEST(Pipeline, MissingInboundOrOutbound) {
Pipeline<int, int> pipeline;
pipeline
.addBack(HandlerAdapter<std::string, std::string>{})
.finalize();
EXPECT_THROW(pipeline.read(0), std::invalid_argument);
EXPECT_THROW(pipeline.readEOF(), std::invalid_argument);
EXPECT_THROW(
pipeline.readException(exception_wrapper(std::runtime_error("blah"))),
std::invalid_argument);
EXPECT_THROW(pipeline.write(0), std::invalid_argument);
EXPECT_THROW(pipeline.close(), std::invalid_argument);
}
TEST(Pipeline, DynamicConstruction) {
{
Pipeline<std::string, std::string> pipeline;
pipeline.addBack(StringHandler());
pipeline.addBack(StringHandler());
// Exercise both addFront and addBack. Final pipeline is
// StI <-> ItS <-> StS <-> StS <-> StI <-> ItS
EXPECT_NO_THROW(
pipeline
.addFront(IntToStringHandler{})
.addFront(StringToIntHandler{})
.addBack(StringToIntHandler{})
.addBack(IntToStringHandler{})
.finalize());
}
}
folly/wangle/codec/ByteToMessageCodec.cpp deleted 100644 → 0
View file @ a716b86b
/*
* Copyright 2015 Facebook, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <folly/wangle/codec/ByteToMessageCodec.h>
namespace folly { namespace wangle {
void ByteToMessageCodec::read(Context* ctx, IOBufQueue& q) {
size_t needed = 0;
std::unique_ptr<IOBuf> result;
while (true) {
result = decode(ctx, q, needed);
if (result) {
ctx->fireRead(std::move(result));
} else {
break;
}
}
}
}} // namespace
folly/wangle/codec/ByteToMessageCodec.h deleted 100644 → 0
View file @ a716b86b
/*
* Copyright 2015 Facebook, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#pragma once
#include <folly/wangle/channel/Handler.h>
namespace folly { namespace wangle {
/**
* A Handler which decodes bytes in a stream-like fashion from
* IOBufQueue to a Message type.
*
* Frame detection
*
* Generally frame detection should be handled earlier in the pipeline
* by adding a DelimiterBasedFrameDecoder, FixedLengthFrameDecoder,
* LengthFieldBasedFrameDecoder, LineBasedFrameDecoder.
*
* If a custom frame decoder is required, then one needs to be careful
* when implementing one with {@link ByteToMessageDecoder}. Ensure
* there are enough bytes in the buffer for a complete frame by
* checking {@link ByteBuf#readableBytes()}. If there are not enough
* bytes for a complete frame, return without modify the reader index
* to allow more bytes to arrive.
*
* To check for complete frames without modify the reader index, use
* IOBufQueue.front(), without split() or pop_front().
*/
class ByteToMessageCodec
: public InboundBytesToBytesHandler {
public:
virtual std::unique_ptr<IOBuf> decode(
Context* ctx, IOBufQueue& buf, size_t&) = 0;
void read(Context* ctx, IOBufQueue& q);
};
}}
folly/wangle/codec/CodecTest.cpp deleted 100644 → 0
View file @ a716b86b
/*
* Copyright 2015 Facebook, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <gtest/gtest.h>
#include <folly/wangle/codec/FixedLengthFrameDecoder.h>
#include <folly/wangle/codec/LengthFieldBasedFrameDecoder.h>
#include <folly/wangle/codec/LengthFieldPrepender.h>
#include <folly/wangle/codec/LineBasedFrameDecoder.h>
using namespace folly;
using namespace folly::wangle;
using namespace folly::io;
class FrameTester
: public InboundHandler<std::unique_ptr<IOBuf>> {
public:
explicit FrameTester(std::function<void(std::unique_ptr<IOBuf>)> test)
: test_(test) {}
void read(Context* ctx, std::unique_ptr<IOBuf> buf) {
test_(std::move(buf));
}
void readException(Context* ctx, exception_wrapper w) {
test_(nullptr);
}
private:
std::function<void(std::unique_ptr<IOBuf>)> test_;
};
class BytesReflector
: public BytesToBytesHandler {
public:
Future<void> write(Context* ctx, std::unique_ptr<IOBuf> buf) {
IOBufQueue q_(IOBufQueue::cacheChainLength());
q_.append(std::move(buf));
ctx->fireRead(q_);
return makeFuture();
}
};
TEST(FixedLengthFrameDecoder, FailWhenLengthFieldEndOffset) {
Pipeline<IOBufQueue&, std::unique_ptr<IOBuf>> pipeline;
int called = 0;
pipeline
.addBack(FixedLengthFrameDecoder(10))
.addBack(FrameTester([&](std::unique_ptr<IOBuf> buf) {
auto sz = buf->computeChainDataLength();
called++;
EXPECT_EQ(sz, 10);
}))
.finalize();
auto buf3 = IOBuf::create(3);
buf3->append(3);
auto buf11 = IOBuf::create(11);
buf11->append(11);
auto buf16 = IOBuf::create(16);
buf16->append(16);
IOBufQueue q(IOBufQueue::cacheChainLength());
q.append(std::move(buf3));
pipeline.read(q);
EXPECT_EQ(called, 0);
q.append(std::move(buf11));
pipeline.read(q);
EXPECT_EQ(called, 1);
q.append(std::move(buf16));
pipeline.read(q);
EXPECT_EQ(called, 3);
}
TEST(LengthFieldFramePipeline, SimpleTest) {
Pipeline<IOBufQueue&, std::unique_ptr<IOBuf>> pipeline;
int called = 0;
pipeline
.addBack(BytesReflector())
.addBack(LengthFieldPrepender())
.addBack(LengthFieldBasedFrameDecoder())
.addBack(FrameTester([&](std::unique_ptr<IOBuf> buf) {
auto sz = buf->computeChainDataLength();
called++;
EXPECT_EQ(sz, 2);
}))
.finalize();
auto buf = IOBuf::create(2);
buf->append(2);
pipeline.write(std::move(buf));
EXPECT_EQ(called, 1);
}
TEST(LengthFieldFramePipeline, LittleEndian) {
Pipeline<IOBufQueue&, std::unique_ptr<IOBuf>> pipeline;
int called = 0;
pipeline
.addBack(BytesReflector())
.addBack(LengthFieldBasedFrameDecoder(4, 100, 0, 0, 4, false))
.addBack(FrameTester([&](std::unique_ptr<IOBuf> buf) {
auto sz = buf->computeChainDataLength();
called++;
EXPECT_EQ(sz, 1);
}))
.addBack(LengthFieldPrepender(4, 0, false, false))
.finalize();
auto buf = IOBuf::create(1);
buf->append(1);
pipeline.write(std::move(buf));
EXPECT_EQ(called, 1);
}
TEST(LengthFieldFrameDecoder, Simple) {
Pipeline<IOBufQueue&, std::unique_ptr<IOBuf>> pipeline;
int called = 0;
pipeline
.addBack(LengthFieldBasedFrameDecoder())
.addBack(FrameTester([&](std::unique_ptr<IOBuf> buf) {
auto sz = buf->computeChainDataLength();
called++;
EXPECT_EQ(sz, 1);
}))
.finalize();
auto bufFrame = IOBuf::create(4);
bufFrame->append(4);
RWPrivateCursor c(bufFrame.get());
c.writeBE((uint32_t)1);
auto bufData = IOBuf::create(1);
bufData->append(1);
IOBufQueue q(IOBufQueue::cacheChainLength());
q.append(std::move(bufFrame));
pipeline.read(q);
EXPECT_EQ(called, 0);
q.append(std::move(bufData));
pipeline.read(q);
EXPECT_EQ(called, 1);
}
TEST(LengthFieldFrameDecoder, NoStrip) {
Pipeline<IOBufQueue&, std::unique_ptr<IOBuf>> pipeline;
int called = 0;
pipeline
.addBack(LengthFieldBasedFrameDecoder(2, 10, 0, 0, 0))
.addBack(FrameTester([&](std::unique_ptr<IOBuf> buf) {
auto sz = buf->computeChainDataLength();
called++;
EXPECT_EQ(sz, 3);
}))
.finalize();
auto bufFrame = IOBuf::create(2);
bufFrame->append(2);
RWPrivateCursor c(bufFrame.get());
c.writeBE((uint16_t)1);
auto bufData = IOBuf::create(1);
bufData->append(1);
IOBufQueue q(IOBufQueue::cacheChainLength());
q.append(std::move(bufFrame));
pipeline.read(q);
EXPECT_EQ(called, 0);
q.append(std::move(bufData));
pipeline.read(q);
EXPECT_EQ(called, 1);
}
TEST(LengthFieldFrameDecoder, Adjustment) {
Pipeline<IOBufQueue&, std::unique_ptr<IOBuf>> pipeline;
int called = 0;
pipeline
.addBack(LengthFieldBasedFrameDecoder(2, 10, 0, -2, 0))
.addBack(FrameTester([&](std::unique_ptr<IOBuf> buf) {
auto sz = buf->computeChainDataLength();
called++;
EXPECT_EQ(sz, 3);
}))
.finalize();
auto bufFrame = IOBuf::create(2);
bufFrame->append(2);
RWPrivateCursor c(bufFrame.get());
c.writeBE((uint16_t)3); // includes frame size
auto bufData = IOBuf::create(1);
bufData->append(1);
IOBufQueue q(IOBufQueue::cacheChainLength());
q.append(std::move(bufFrame));
pipeline.read(q);
EXPECT_EQ(called, 0);
q.append(std::move(bufData));
pipeline.read(q);
EXPECT_EQ(called, 1);
}
TEST(LengthFieldFrameDecoder, PreHeader) {
Pipeline<IOBufQueue&, std::unique_ptr<IOBuf>> pipeline;
int called = 0;
pipeline
.addBack(LengthFieldBasedFrameDecoder(2, 10, 2, 0, 0))
.addBack(FrameTester([&](std::unique_ptr<IOBuf> buf) {
auto sz = buf->computeChainDataLength();
called++;
EXPECT_EQ(sz, 5);
}))
.finalize();
auto bufFrame = IOBuf::create(4);
bufFrame->append(4);
RWPrivateCursor c(bufFrame.get());
c.write((uint16_t)100); // header
c.writeBE((uint16_t)1); // frame size
auto bufData = IOBuf::create(1);
bufData->append(1);
IOBufQueue q(IOBufQueue::cacheChainLength());
q.append(std::move(bufFrame));
pipeline.read(q);
EXPECT_EQ(called, 0);
q.append(std::move(bufData));
pipeline.read(q);
EXPECT_EQ(called, 1);
}
TEST(LengthFieldFrameDecoder, PostHeader) {
Pipeline<IOBufQueue&, std::unique_ptr<IOBuf>> pipeline;
int called = 0;
pipeline
.addBack(LengthFieldBasedFrameDecoder(2, 10, 0, 2, 0))
.addBack(FrameTester([&](std::unique_ptr<IOBuf> buf) {
auto sz = buf->computeChainDataLength();
called++;
EXPECT_EQ(sz, 5);
}))
.finalize();
auto bufFrame = IOBuf::create(4);
bufFrame->append(4);
RWPrivateCursor c(bufFrame.get());
c.writeBE((uint16_t)1); // frame size
c.write((uint16_t)100); // header
auto bufData = IOBuf::create(1);
bufData->append(1);
IOBufQueue q(IOBufQueue::cacheChainLength());
q.append(std::move(bufFrame));
pipeline.read(q);
EXPECT_EQ(called, 0);
q.append(std::move(bufData));
pipeline.read(q);
EXPECT_EQ(called, 1);
}
TEST(LengthFieldFrameDecoderStrip, PrePostHeader) {
Pipeline<IOBufQueue&, std::unique_ptr<IOBuf>> pipeline;
int called = 0;
pipeline
.addBack(LengthFieldBasedFrameDecoder(2, 10, 2, 2, 4))
.addBack(FrameTester([&](std::unique_ptr<IOBuf> buf) {
auto sz = buf->computeChainDataLength();
called++;
EXPECT_EQ(sz, 3);
}))
.finalize();
auto bufFrame = IOBuf::create(6);
bufFrame->append(6);
RWPrivateCursor c(bufFrame.get());
c.write((uint16_t)100); // pre header
c.writeBE((uint16_t)1); // frame size
c.write((uint16_t)100); // post header
auto bufData = IOBuf::create(1);
bufData->append(1);
IOBufQueue q(IOBufQueue::cacheChainLength());
q.append(std::move(bufFrame));
pipeline.read(q);
EXPECT_EQ(called, 0);
q.append(std::move(bufData));
pipeline.read(q);
EXPECT_EQ(called, 1);
}
TEST(LengthFieldFrameDecoder, StripPrePostHeaderFrameInclHeader) {
Pipeline<IOBufQueue&, std::unique_ptr<IOBuf>> pipeline;
int called = 0;
pipeline
.addBack(LengthFieldBasedFrameDecoder(2, 10, 2, -2, 4))
.addBack(FrameTester([&](std::unique_ptr<IOBuf> buf) {
auto sz = buf->computeChainDataLength();
called++;
EXPECT_EQ(sz, 3);
}))
.finalize();
auto bufFrame = IOBuf::create(6);
bufFrame->append(6);
RWPrivateCursor c(bufFrame.get());
c.write((uint16_t)100); // pre header
c.writeBE((uint16_t)5); // frame size
c.write((uint16_t)100); // post header
auto bufData = IOBuf::create(1);
bufData->append(1);
IOBufQueue q(IOBufQueue::cacheChainLength());
q.append(std::move(bufFrame));
pipeline.read(q);
EXPECT_EQ(called, 0);
q.append(std::move(bufData));
pipeline.read(q);
EXPECT_EQ(called, 1);
}
TEST(LengthFieldFrameDecoder, FailTestLengthFieldEndOffset) {
Pipeline<IOBufQueue&, std::unique_ptr<IOBuf>> pipeline;
int called = 0;
pipeline
.addBack(LengthFieldBasedFrameDecoder(4, 10, 4, -2, 4))
.addBack(FrameTester([&](std::unique_ptr<IOBuf> buf) {
ASSERT_EQ(nullptr, buf);
called++;
}))
.finalize();
auto bufFrame = IOBuf::create(8);
bufFrame->append(8);
RWPrivateCursor c(bufFrame.get());
c.writeBE((uint32_t)0); // frame size
c.write((uint32_t)0); // crap
IOBufQueue q(IOBufQueue::cacheChainLength());
q.append(std::move(bufFrame));
pipeline.read(q);
EXPECT_EQ(called, 1);
}
TEST(LengthFieldFrameDecoder, FailTestLengthFieldFrameSize) {
Pipeline<IOBufQueue&, std::unique_ptr<IOBuf>> pipeline;
int called = 0;
pipeline
.addBack(LengthFieldBasedFrameDecoder(4, 10, 0, 0, 4))
.addBack(FrameTester([&](std::unique_ptr<IOBuf> buf) {
ASSERT_EQ(nullptr, buf);
called++;
}))
.finalize();
auto bufFrame = IOBuf::create(16);
bufFrame->append(16);
RWPrivateCursor c(bufFrame.get());
c.writeBE((uint32_t)12); // frame size
c.write((uint32_t)0); // nothing
c.write((uint32_t)0); // nothing
c.write((uint32_t)0); // nothing
IOBufQueue q(IOBufQueue::cacheChainLength());
q.append(std::move(bufFrame));
pipeline.read(q);
EXPECT_EQ(called, 1);
}
TEST(LengthFieldFrameDecoder, FailTestLengthFieldInitialBytes) {
Pipeline<IOBufQueue&, std::unique_ptr<IOBuf>> pipeline;
int called = 0;
pipeline
.addBack(LengthFieldBasedFrameDecoder(4, 10, 0, 0, 10))
.addBack(FrameTester([&](std::unique_ptr<IOBuf> buf) {
ASSERT_EQ(nullptr, buf);
called++;
}))
.finalize();
auto bufFrame = IOBuf::create(16);
bufFrame->append(16);
RWPrivateCursor c(bufFrame.get());
c.writeBE((uint32_t)4); // frame size
c.write((uint32_t)0); // nothing
c.write((uint32_t)0); // nothing
c.write((uint32_t)0); // nothing
IOBufQueue q(IOBufQueue::cacheChainLength());
q.append(std::move(bufFrame));
pipeline.read(q);
EXPECT_EQ(called, 1);
}
TEST(LineBasedFrameDecoder, Simple) {
Pipeline<IOBufQueue&, std::unique_ptr<IOBuf>> pipeline;
int called = 0;
pipeline
.addBack(LineBasedFrameDecoder(10))
.addBack(FrameTester([&](std::unique_ptr<IOBuf> buf) {
auto sz = buf->computeChainDataLength();
called++;
EXPECT_EQ(sz, 3);
}))
.finalize();
auto buf = IOBuf::create(3);
buf->append(3);
IOBufQueue q(IOBufQueue::cacheChainLength());
q.append(std::move(buf));
pipeline.read(q);
EXPECT_EQ(called, 0);
buf = IOBuf::create(1);
buf->append(1);
RWPrivateCursor c(buf.get());
c.write<char>('\n');
q.append(std::move(buf));
pipeline.read(q);
EXPECT_EQ(called, 1);
buf = IOBuf::create(4);
buf->append(4);
RWPrivateCursor c1(buf.get());
c1.write(' ');
c1.write(' ');
c1.write(' ');
c1.write('\r');
q.append(std::move(buf));
pipeline.read(q);
EXPECT_EQ(called, 1);
buf = IOBuf::create(1);
buf->append(1);
RWPrivateCursor c2(buf.get());
c2.write('\n');
q.append(std::move(buf));
pipeline.read(q);
EXPECT_EQ(called, 2);
}
TEST(LineBasedFrameDecoder, SaveDelimiter) {
Pipeline<IOBufQueue&, std::unique_ptr<IOBuf>> pipeline;
int called = 0;
pipeline
.addBack(LineBasedFrameDecoder(10, false))
.addBack(FrameTester([&](std::unique_ptr<IOBuf> buf) {
auto sz = buf->computeChainDataLength();
called++;
EXPECT_EQ(sz, 4);
}))
.finalize();
auto buf = IOBuf::create(3);
buf->append(3);
IOBufQueue q(IOBufQueue::cacheChainLength());
q.append(std::move(buf));
pipeline.read(q);
EXPECT_EQ(called, 0);
buf = IOBuf::create(1);
buf->append(1);
RWPrivateCursor c(buf.get());
c.write<char>('\n');
q.append(std::move(buf));
pipeline.read(q);
EXPECT_EQ(called, 1);
buf = IOBuf::create(3);
buf->append(3);
RWPrivateCursor c1(buf.get());
c1.write(' ');
c1.write(' ');
c1.write('\r');
q.append(std::move(buf));
pipeline.read(q);
EXPECT_EQ(called, 1);
buf = IOBuf::create(1);
buf->append(1);
RWPrivateCursor c2(buf.get());
c2.write('\n');
q.append(std::move(buf));
pipeline.read(q);
EXPECT_EQ(called, 2);
}
TEST(LineBasedFrameDecoder, Fail) {
Pipeline<IOBufQueue&, std::unique_ptr<IOBuf>> pipeline;
int called = 0;
pipeline
.addBack(LineBasedFrameDecoder(10))
.addBack(FrameTester([&](std::unique_ptr<IOBuf> buf) {
ASSERT_EQ(nullptr, buf);
called++;
}))
.finalize();
auto buf = IOBuf::create(11);
buf->append(11);
IOBufQueue q(IOBufQueue::cacheChainLength());
q.append(std::move(buf));
pipeline.read(q);
EXPECT_EQ(called, 1);
buf = IOBuf::create(1);
buf->append(1);
q.append(std::move(buf));
pipeline.read(q);
EXPECT_EQ(called, 1);
buf = IOBuf::create(2);
buf->append(2);
RWPrivateCursor c(buf.get());
c.write(' ');
c.write<char>('\n');
q.append(std::move(buf));
pipeline.read(q);
EXPECT_EQ(called, 1);
buf = IOBuf::create(12);
buf->append(12);
RWPrivateCursor c2(buf.get());
for (int i = 0; i < 11; i++) {
c2.write(' ');
}
c2.write<char>('\n');
q.append(std::move(buf));
pipeline.read(q);
EXPECT_EQ(called, 2);
}
TEST(LineBasedFrameDecoder, NewLineOnly) {
Pipeline<IOBufQueue&, std::unique_ptr<IOBuf>> pipeline;
int called = 0;
pipeline
.addBack(LineBasedFrameDecoder(
10, true, LineBasedFrameDecoder::TerminatorType::NEWLINE))
.addBack(FrameTester([&](std::unique_ptr<IOBuf> buf) {
auto sz = buf->computeChainDataLength();
called++;
EXPECT_EQ(sz, 1);
}))
.finalize();
auto buf = IOBuf::create(2);
buf->append(2);
RWPrivateCursor c(buf.get());
c.write<char>('\r');
c.write<char>('\n');
IOBufQueue q(IOBufQueue::cacheChainLength());
q.append(std::move(buf));
pipeline.read(q);
EXPECT_EQ(called, 1);
}
TEST(LineBasedFrameDecoder, CarriageNewLineOnly) {
Pipeline<IOBufQueue&, std::unique_ptr<IOBuf>> pipeline;
int called = 0;
pipeline
.addBack(LineBasedFrameDecoder(
10, true, LineBasedFrameDecoder::TerminatorType::CARRIAGENEWLINE))
.addBack(FrameTester([&](std::unique_ptr<IOBuf> buf) {
auto sz = buf->computeChainDataLength();
called++;
EXPECT_EQ(sz, 1);
}))
.finalize();
auto buf = IOBuf::create(3);
buf->append(3);
RWPrivateCursor c(buf.get());
c.write<char>('\n');
c.write<char>('\r');
c.write<char>('\n');
IOBufQueue q(IOBufQueue::cacheChainLength());
q.append(std::move(buf));
pipeline.read(q);
EXPECT_EQ(called, 1);
}
folly/wangle/codec/FixedLengthFrameDecoder.h deleted 100644 → 0
View file @ a716b86b
/*
* Copyright 2015 Facebook, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#pragma once
#include <folly/wangle/codec/ByteToMessageCodec.h>
namespace folly {namespace wangle {
/**
* A decoder that splits the received IOBufs by the fixed number
* of bytes. For example, if you received the following four
* fragmented packets:
*
* +---+----+------+----+
* | A | BC | DEFG | HI |
* +---+----+------+----+
*
* A FixedLengthFrameDecoder will decode them into the following three
* packets with the fixed length:
*
* +-----+-----+-----+
* | ABC | DEF | GHI |
* +-----+-----+-----+
*
*/
class FixedLengthFrameDecoder
: public ByteToMessageCodec {
public:
FixedLengthFrameDecoder(size_t length)
: length_(length) {}
std::unique_ptr<IOBuf> decode(Context* ctx, IOBufQueue& q, size_t& needed) {
if (q.chainLength() < length_) {
needed = length_ - q.chainLength();
return nullptr;
}
return q.split(length_);
}
private:
size_t length_;
};
}} // Namespace
folly/wangle/codec/LengthFieldBasedFrameDecoder.cpp deleted 100644 → 0
View file @ a716b86b
/*
* Copyright 2015 Facebook, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <folly/wangle/codec/LengthFieldBasedFrameDecoder.h>
namespace folly { namespace wangle {
LengthFieldBasedFrameDecoder::LengthFieldBasedFrameDecoder(
uint32_t lengthFieldLength,
uint32_t maxFrameLength,
uint32_t lengthFieldOffset,
uint32_t lengthAdjustment,
uint32_t initialBytesToStrip,
bool networkByteOrder)
: lengthFieldLength_(lengthFieldLength)
, maxFrameLength_(maxFrameLength)
, lengthFieldOffset_(lengthFieldOffset)
, lengthAdjustment_(lengthAdjustment)
, initialBytesToStrip_(initialBytesToStrip)
, networkByteOrder_(networkByteOrder)
, lengthFieldEndOffset_(lengthFieldOffset + lengthFieldLength) {
CHECK(maxFrameLength > 0);
CHECK(lengthFieldOffset <= maxFrameLength - lengthFieldLength);
}
std::unique_ptr<IOBuf> LengthFieldBasedFrameDecoder::decode(
Context* ctx, IOBufQueue& buf, size_t&) {
// discarding too long frame
if (buf.chainLength() < lengthFieldEndOffset_) {
return nullptr;
}
uint64_t frameLength = getUnadjustedFrameLength(
buf, lengthFieldOffset_, lengthFieldLength_, networkByteOrder_);
frameLength += lengthAdjustment_ + lengthFieldEndOffset_;
if (frameLength < lengthFieldEndOffset_) {
buf.trimStart(lengthFieldEndOffset_);
ctx->fireReadException(folly::make_exception_wrapper<std::runtime_error>(
"Frame too small"));
return nullptr;
}
if (frameLength > maxFrameLength_) {
buf.trimStart(frameLength);
ctx->fireReadException(folly::make_exception_wrapper<std::runtime_error>(
"Frame larger than " +
folly::to<std::string>(maxFrameLength_)));
return nullptr;
}
if (buf.chainLength() < frameLength) {
return nullptr;
}
if (initialBytesToStrip_ > frameLength) {
buf.trimStart(frameLength);
ctx->fireReadException(folly::make_exception_wrapper<std::runtime_error>(
"InitialBytesToSkip larger than frame"));
return nullptr;
}
buf.trimStart(initialBytesToStrip_);
int actualFrameLength = frameLength - initialBytesToStrip_;
return buf.split(actualFrameLength);
}
uint64_t LengthFieldBasedFrameDecoder::getUnadjustedFrameLength(
IOBufQueue& buf, int offset, int length, bool networkByteOrder) {
folly::io::Cursor c(buf.front());
uint64_t frameLength;
c.skip(offset);
switch(length) {
case 1:{
if (networkByteOrder) {
frameLength = c.readBE<uint8_t>();
} else {
frameLength = c.readLE<uint8_t>();
}
break;
}
case 2:{
if (networkByteOrder) {
frameLength = c.readBE<uint16_t>();
} else {
frameLength = c.readLE<uint16_t>();
}
break;
}
case 4:{
if (networkByteOrder) {
frameLength = c.readBE<uint32_t>();
} else {
frameLength = c.readLE<uint32_t>();
}
break;
}
case 8:{
if (networkByteOrder) {
frameLength = c.readBE<uint64_t>();
} else {
frameLength = c.readLE<uint64_t>();
}
break;
}
}
return frameLength;
}
}} // namespace
folly/wangle/codec/LengthFieldBasedFrameDecoder.h deleted 100644 → 0
View file @ a716b86b
/*
* Copyright 2015 Facebook, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#pragma once
#include <folly/wangle/codec/ByteToMessageCodec.h>
#include <folly/io/Cursor.h>
namespace folly { namespace wangle {
/**
* A decoder that splits the received IOBufs dynamically by the
* value of the length field in the message. It is particularly useful when you
* decode a binary message which has an integer header field that represents the
* length of the message body or the whole message.
*
* LengthFieldBasedFrameDecoder has many configuration parameters so
* that it can decode any message with a length field, which is often seen in
* proprietary client-server protocols. Here are some example that will give
* you the basic idea on which option does what.
*
* 2 bytes length field at offset 0, do not strip header
*
* The value of the length field in this example is 12 (0x0C) which
* represents the length of "HELLO, WORLD". By default, the decoder assumes
* that the length field represents the number of the bytes that follows the
* length field. Therefore, it can be decoded with the simplistic parameter
* combination.
*
* lengthFieldOffset = 0
* lengthFieldLength = 2
* lengthAdjustment = 0
* initialBytesToStrip = 0 (= do not strip header)
*
* BEFORE DECODE (14 bytes) AFTER DECODE (14 bytes)
* +--------+----------------+ +--------+----------------+
* | Length | Actual Content |----->| Length | Actual Content |
* | 0x000C | "HELLO, WORLD" | | 0x000C | "HELLO, WORLD" |
* +--------+----------------+ +--------+----------------+
*
*
* 2 bytes length field at offset 0, strip header
*
* Because we can get the length of the content by calling
* ioBuf->computeChainDataLength(), you might want to strip the length
* field by specifying initialBytesToStrip. In this example, we
* specified 2, that is same with the length of the length field, to
* strip the first two bytes.
*
* lengthFieldOffset = 0
* lengthFieldLength = 2
* lengthAdjustment = 0
* initialBytesToStrip = 2 (= the length of the Length field)
*
* BEFORE DECODE (14 bytes) AFTER DECODE (12 bytes)
* +--------+----------------+ +----------------+
* | Length | Actual Content |----->| Actual Content |
* | 0x000C | "HELLO, WORLD" | | "HELLO, WORLD" |
* +--------+----------------+ +----------------+
*
*
* 2 bytes length field at offset 0, do not strip header, the length field
* represents the length of the whole message
*
* In most cases, the length field represents the length of the message body
* only, as shown in the previous examples. However, in some protocols, the
* length field represents the length of the whole message, including the
* message header. In such a case, we specify a non-zero
* lengthAdjustment. Because the length value in this example message
* is always greater than the body length by 2, we specify -2
* as lengthAdjustment for compensation.
*
* lengthFieldOffset = 0
* lengthFieldLength = 2
* lengthAdjustment = -2 (= the length of the Length field)
* initialBytesToStrip = 0
*
* BEFORE DECODE (14 bytes) AFTER DECODE (14 bytes)
* +--------+----------------+ +--------+----------------+
* | Length | Actual Content |----->| Length | Actual Content |
* | 0x000E | "HELLO, WORLD" | | 0x000E | "HELLO, WORLD" |
* +--------+----------------+ +--------+----------------+
*
*
* 3 bytes length field at the end of 5 bytes header, do not strip header
*
* The following message is a simple variation of the first example. An extra
* header value is prepended to the message. lengthAdjustment is zero
* again because the decoder always takes the length of the prepended data into
* account during frame length calculation.
*
* lengthFieldOffset = 2 (= the length of Header 1)
* lengthFieldLength = 3
* lengthAdjustment = 0
* initialBytesToStrip = 0
*
* BEFORE DECODE (17 bytes) AFTER DECODE (17 bytes)
* +----------+----------+----------------+ +----------+----------+----------------+
* | Header 1 | Length | Actual Content |----->| Header 1 | Length | Actual Content |
* | 0xCAFE | 0x00000C | "HELLO, WORLD" | | 0xCAFE | 0x00000C | "HELLO, WORLD" |
* +----------+----------+----------------+ +----------+----------+----------------+
*
*
* 3 bytes length field at the beginning of 5 bytes header, do not strip header
*
* This is an advanced example that shows the case where there is an extra
* header between the length field and the message body. You have to specify a
* positive lengthAdjustment so that the decoder counts the extra
* header into the frame length calculation.
*
* lengthFieldOffset = 0
* lengthFieldLength = 3
* lengthAdjustment = 2 (= the length of Header 1)
* initialBytesToStrip = 0
*
* BEFORE DECODE (17 bytes) AFTER DECODE (17 bytes)
* +----------+----------+----------------+ +----------+----------+----------------+
* | Length | Header 1 | Actual Content |----->| Length | Header 1 | Actual Content |
* | 0x00000C | 0xCAFE | "HELLO, WORLD" | | 0x00000C | 0xCAFE | "HELLO, WORLD" |
* +----------+----------+----------------+ +----------+----------+----------------+
*
*
* 2 bytes length field at offset 1 in the middle of 4 bytes header,
* strip the first header field and the length field
*
* This is a combination of all the examples above. There are the prepended
* header before the length field and the extra header after the length field.
* The prepended header affects the lengthFieldOffset and the extra
* header affects the lengthAdjustment. We also specified a non-zero
* initialBytesToStrip to strip the length field and the prepended
* header from the frame. If you don't want to strip the prepended header, you
* could specify 0 for initialBytesToSkip.
*
* lengthFieldOffset = 1 (= the length of HDR1)
* lengthFieldLength = 2
* lengthAdjustment = 1 (= the length of HDR2)
* initialBytesToStrip = 3 (= the length of HDR1 + LEN)
*
* BEFORE DECODE (16 bytes) AFTER DECODE (13 bytes)
* +------+--------+------+----------------+ +------+----------------+
* | HDR1 | Length | HDR2 | Actual Content |----->| HDR2 | Actual Content |
* | 0xCA | 0x000C | 0xFE | "HELLO, WORLD" | | 0xFE | "HELLO, WORLD" |
* +------+--------+------+----------------+ +------+----------------+
*
*
* 2 bytes length field at offset 1 in the middle of 4 bytes header,
* strip the first header field and the length field, the length field
* represents the length of the whole message
*
* Let's give another twist to the previous example. The only difference from
* the previous example is that the length field represents the length of the
* whole message instead of the message body, just like the third example.
* We have to count the length of HDR1 and Length into lengthAdjustment.
* Please note that we don't need to take the length of HDR2 into account
* because the length field already includes the whole header length.
*
* lengthFieldOffset = 1
* lengthFieldLength = 2
* lengthAdjustment = -3 (= the length of HDR1 + LEN, negative)
* initialBytesToStrip = 3
*
* BEFORE DECODE (16 bytes) AFTER DECODE (13 bytes)
* +------+--------+------+----------------+ +------+----------------+
* | HDR1 | Length | HDR2 | Actual Content |----->| HDR2 | Actual Content |
* | 0xCA | 0x0010 | 0xFE | "HELLO, WORLD" | | 0xFE | "HELLO, WORLD" |
* +------+--------+------+----------------+ +------+----------------+
*
* @see LengthFieldPrepender
*/
class LengthFieldBasedFrameDecoder : public ByteToMessageCodec {
public:
LengthFieldBasedFrameDecoder(
uint32_t lengthFieldLength = 4,
uint32_t maxFrameLength = UINT_MAX,
uint32_t lengthFieldOffset = 0,
uint32_t lengthAdjustment = 0,
uint32_t initialBytesToStrip = 4,
bool networkByteOrder = true);
std::unique_ptr<IOBuf> decode(Context* ctx, IOBufQueue& buf, size_t&);
private:
uint64_t getUnadjustedFrameLength(
IOBufQueue& buf, int offset, int length, bool networkByteOrder);
uint32_t lengthFieldLength_;
uint32_t maxFrameLength_;
uint32_t lengthFieldOffset_;
uint32_t lengthAdjustment_;
uint32_t initialBytesToStrip_;
bool networkByteOrder_;
uint32_t lengthFieldEndOffset_;
};
}} // namespace
folly/wangle/codec/LengthFieldPrepender.cpp deleted 100644 → 0
View file @ a716b86b
/*
* Copyright 2015 Facebook, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <folly/wangle/codec/LengthFieldPrepender.h>
namespace folly { namespace wangle {
LengthFieldPrepender::LengthFieldPrepender(
int lengthFieldLength,
int lengthAdjustment,
bool lengthIncludesLengthField,
bool networkByteOrder)
: lengthFieldLength_(lengthFieldLength)
, lengthAdjustment_(lengthAdjustment)
, lengthIncludesLengthField_(lengthIncludesLengthField)
, networkByteOrder_(networkByteOrder) {
CHECK(lengthFieldLength == 1 ||
lengthFieldLength == 2 ||
lengthFieldLength == 4 ||
lengthFieldLength == 8 );
}
Future<void> LengthFieldPrepender::write(
Context* ctx, std::unique_ptr<IOBuf> buf) {
int length = lengthAdjustment_ + buf->computeChainDataLength();
if (lengthIncludesLengthField_) {
length += lengthFieldLength_;
}
if (length < 0) {
throw std::runtime_error("Length field < 0");
}
auto len = IOBuf::create(lengthFieldLength_);
len->append(lengthFieldLength_);
folly::io::RWPrivateCursor c(len.get());
switch (lengthFieldLength_) {
case 1: {
if (length >= 256) {
throw std::runtime_error("length does not fit byte");
}
if (networkByteOrder_) {
c.writeBE((uint8_t)length);
} else {
c.writeLE((uint8_t)length);
}
break;
}
case 2: {
if (length >= 65536) {
throw std::runtime_error("length does not fit byte");
}
if (networkByteOrder_) {
c.writeBE((uint16_t)length);
} else {
c.writeLE((uint16_t)length);
}
break;
}
case 4: {
if (networkByteOrder_) {
c.writeBE((uint32_t)length);
} else {
c.writeLE((uint32_t)length);
}
break;
}
case 8: {
if (networkByteOrder_) {
c.writeBE((uint64_t)length);
} else {
c.writeLE((uint64_t)length);
}
break;
}
default: {
throw std::runtime_error("Invalid lengthFieldLength");
}
}
len->prependChain(std::move(buf));
return ctx->fireWrite(std::move(len));
}
}} // Namespace
folly/wangle/codec/LengthFieldPrepender.h deleted 100644 → 0
View file @ a716b86b
/*
* Copyright 2015 Facebook, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#pragma once
#include <folly/wangle/codec/ByteToMessageCodec.h>
#include <folly/io/Cursor.h>
namespace folly { namespace wangle {
/**
* An encoder that prepends the length of the message. The length value is
* prepended as a binary form.
*
* For example, LengthFieldPrepender(2)will encode the
* following 12-bytes string:
*
* +----------------+
* | "HELLO, WORLD" |
* +----------------+
*
* into the following:
*
* +--------+----------------+
* + 0x000C | "HELLO, WORLD" |
* +--------+----------------+
*
* If you turned on the lengthIncludesLengthFieldLength flag in the
* constructor, the encoded data would look like the following
* (12 (original data) + 2 (prepended data) = 14 (0xE)):
*
* +--------+----------------+
* + 0x000E | "HELLO, WORLD" |
* +--------+----------------+
*
*/
class LengthFieldPrepender
: public OutboundBytesToBytesHandler {
public:
LengthFieldPrepender(
int lengthFieldLength = 4,
int lengthAdjustment = 0,
bool lengthIncludesLengthField = false,
bool networkByteOrder = true);
Future<void> write(Context* ctx, std::unique_ptr<IOBuf> buf);
private:
int lengthFieldLength_;
int lengthAdjustment_;
bool lengthIncludesLengthField_;
bool networkByteOrder_;
};
}} // namespace
folly/wangle/codec/LineBasedFrameDecoder.cpp deleted 100644 → 0
View file @ a716b86b
/*
* Copyright 2015 Facebook, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <folly/wangle/codec/LineBasedFrameDecoder.h>
namespace folly { namespace wangle {
using folly::io::Cursor;
LineBasedFrameDecoder::LineBasedFrameDecoder(uint32_t maxLength,
bool stripDelimiter,
TerminatorType terminatorType)
: maxLength_(maxLength)
, stripDelimiter_(stripDelimiter)
, terminatorType_(terminatorType) {}
std::unique_ptr<IOBuf> LineBasedFrameDecoder::decode(
Context* ctx, IOBufQueue& buf, size_t&) {
int64_t eol = findEndOfLine(buf);
if (!discarding_) {
if (eol >= 0) {
Cursor c(buf.front());
c += eol;
auto delimLength = c.read<char>() == '\r' ? 2 : 1;
if (eol > maxLength_) {
buf.split(eol + delimLength);
fail(ctx, folly::to<std::string>(eol));
return nullptr;
}
std::unique_ptr<folly::IOBuf> frame;
if (stripDelimiter_) {
frame = buf.split(eol);
buf.trimStart(delimLength);
} else {
frame = buf.split(eol + delimLength);
}
return std::move(frame);
} else {
auto len = buf.chainLength();
if (len > maxLength_) {
discardedBytes_ = len;
buf.trimStart(len);
discarding_ = true;
fail(ctx, "over " + folly::to<std::string>(len));
}
return nullptr;
}
} else {
if (eol >= 0) {
Cursor c(buf.front());
c += eol;
auto delimLength = c.read<char>() == '\r' ? 2 : 1;
buf.trimStart(eol + delimLength);
discardedBytes_ = 0;
discarding_ = false;
} else {
discardedBytes_ = buf.chainLength();
buf.move();
}
return nullptr;
}
}
void LineBasedFrameDecoder::fail(Context* ctx, std::string len) {
ctx->fireReadException(
folly::make_exception_wrapper<std::runtime_error>(
"frame length" + len +
" exeeds max " + folly::to<std::string>(maxLength_)));
}
int64_t LineBasedFrameDecoder::findEndOfLine(IOBufQueue& buf) {
Cursor c(buf.front());
for (uint32_t i = 0; i < maxLength_ && i < buf.chainLength(); i++) {
auto b = c.read<char>();
if (b == '\n' && terminatorType_ != TerminatorType::CARRIAGENEWLINE) {
return i;
} else if (terminatorType_ != TerminatorType::NEWLINE &&
b == '\r' && !c.isAtEnd() && c.read<char>() == '\n') {
return i;
}
}
return -1;
}
}} // namespace
folly/wangle/codec/LineBasedFrameDecoder.h deleted 100644 → 0
View file @ a716b86b
/*
* Copyright 2015 Facebook, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#pragma once
#include <folly/wangle/codec/ByteToMessageCodec.h>
#include <folly/io/Cursor.h>
namespace folly { namespace wangle {
/**
* A decoder that splits the received IOBufQueue on line endings.
*
* Both "\n" and "\r\n" are handled, or optionally reqire only
* one or the other.
*/
class LineBasedFrameDecoder : public ByteToMessageCodec {
public:
enum class TerminatorType {
BOTH,
NEWLINE,
CARRIAGENEWLINE
};
LineBasedFrameDecoder(uint32_t maxLength = UINT_MAX,
bool stripDelimiter = true,
TerminatorType terminatorType =
TerminatorType::BOTH);
std::unique_ptr<IOBuf> decode(Context* ctx, IOBufQueue& buf, size_t&);
private:
int64_t findEndOfLine(IOBufQueue& buf);
void fail(Context* ctx, std::string len);
uint32_t maxLength_;
bool stripDelimiter_;
bool discarding_{false};
uint32_t discardedBytes_{0};
TerminatorType terminatorType_;
};
}} // namespace
folly/wangle/codec/README.md deleted 100644 → 0
View file @ a716b86b
Codecs are modeled after netty's codecs:
https://github.com/netty/netty/tree/master/codec/src/main/java/io/netty/handler/codec
Most of the changes are due to differing memory allocation strategies.
\ No newline at end of file
folly/wangle/codec/StringCodec.h deleted 100644 → 0
View file @ a716b86b
/*
* Copyright 2015 Facebook, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#pragma once
#include <folly/wangle/channel/Handler.h>
namespace folly { namespace wangle {
/*
* StringCodec converts a pipeline from IOBufs to std::strings.
*/
class StringCodec : public Handler<std::unique_ptr<IOBuf>, std::string,
std::string, std::unique_ptr<IOBuf>> {
public:
typedef typename Handler<
std::unique_ptr<IOBuf>, std::string,
std::string, std::unique_ptr<IOBuf>>::Context Context;
void read(Context* ctx, std::unique_ptr<IOBuf> buf) override {
buf->coalesce();
std::string data((const char*)buf->data(), buf->length());
ctx->fireRead(data);
}
Future<void> write(Context* ctx, std::string msg) override {
auto buf = IOBuf::copyBuffer(msg.data(), msg.length());
return ctx->fireWrite(std::move(buf));
}
};
}} // namespace
folly/wangle/concurrent/BlockingQueue.h deleted 100644 → 0
View file @ a716b86b
/*
* Copyright 2015 Facebook, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#pragma once
#include <glog/logging.h>
namespace folly { namespace wangle {
template <class T>
class BlockingQueue {
public:
virtual ~BlockingQueue() {}
virtual void add(T item) = 0;
virtual void addWithPriority(T item, int8_t priority) {
add(std::move(item));
}
virtual uint8_t getNumPriorities() {
return 1;
}
virtual T take() = 0;
virtual size_t size() = 0;
};
}} // folly::wangle
folly/wangle/concurrent/CPUThreadPoolExecutor.cpp deleted 100644 → 0
View file @ a716b86b
/*
* Copyright 2015 Facebook, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <folly/wangle/concurrent/CPUThreadPoolExecutor.h>
#include <folly/wangle/concurrent/PriorityLifoSemMPMCQueue.h>
namespace folly { namespace wangle {
const size_t CPUThreadPoolExecutor::kDefaultMaxQueueSize = 1 << 14;
CPUThreadPoolExecutor::CPUThreadPoolExecutor(
size_t numThreads,
std::unique_ptr<BlockingQueue<CPUTask>> taskQueue,
std::shared_ptr<ThreadFactory> threadFactory)
: ThreadPoolExecutor(numThreads, std::move(threadFactory)),
taskQueue_(std::move(taskQueue)) {
addThreads(numThreads);
CHECK(threadList_.get().size() == numThreads);
}
CPUThreadPoolExecutor::CPUThreadPoolExecutor(
size_t numThreads,
std::shared_ptr<ThreadFactory> threadFactory)
: CPUThreadPoolExecutor(
numThreads,
folly::make_unique<LifoSemMPMCQueue<CPUTask>>(
CPUThreadPoolExecutor::kDefaultMaxQueueSize),
std::move(threadFactory)) {}
CPUThreadPoolExecutor::CPUThreadPoolExecutor(size_t numThreads)
: CPUThreadPoolExecutor(
numThreads,
std::make_shared<NamedThreadFactory>("CPUThreadPool")) {}
CPUThreadPoolExecutor::CPUThreadPoolExecutor(
size_t numThreads,
int8_t numPriorities,
std::shared_ptr<ThreadFactory> threadFactory)
: CPUThreadPoolExecutor(
numThreads,
folly::make_unique<PriorityLifoSemMPMCQueue<CPUTask>>(
numPriorities,
CPUThreadPoolExecutor::kDefaultMaxQueueSize),
std::move(threadFactory)) {}
CPUThreadPoolExecutor::CPUThreadPoolExecutor(
size_t numThreads,
int8_t numPriorities,
size_t maxQueueSize,
std::shared_ptr<ThreadFactory> threadFactory)
: CPUThreadPoolExecutor(
numThreads,
folly::make_unique<PriorityLifoSemMPMCQueue<CPUTask>>(
numPriorities,
maxQueueSize),
std::move(threadFactory)) {}
CPUThreadPoolExecutor::~CPUThreadPoolExecutor() {
stop();
CHECK(threadsToStop_ == 0);
}
void CPUThreadPoolExecutor::add(Func func) {
add(std::move(func), std::chrono::milliseconds(0));
}
void CPUThreadPoolExecutor::add(
Func func,
std::chrono::milliseconds expiration,
Func expireCallback) {
// TODO handle enqueue failure, here and in other add() callsites
taskQueue_->add(
CPUTask(std::move(func), expiration, std::move(expireCallback)));
}
void CPUThreadPoolExecutor::addWithPriority(Func func, int8_t priority) {
add(std::move(func), priority, std::chrono::milliseconds(0));
}
void CPUThreadPoolExecutor::add(
Func func,
int8_t priority,
std::chrono::milliseconds expiration,
Func expireCallback) {
CHECK(getNumPriorities() > 0);
taskQueue_->addWithPriority(
CPUTask(std::move(func), expiration, std::move(expireCallback)),
priority);
}
uint8_t CPUThreadPoolExecutor::getNumPriorities() const {
return taskQueue_->getNumPriorities();
}
BlockingQueue<CPUThreadPoolExecutor::CPUTask>*
CPUThreadPoolExecutor::getTaskQueue() {
return taskQueue_.get();
}
void CPUThreadPoolExecutor::threadRun(std::shared_ptr<Thread> thread) {
thread->startupBaton.post();
while (1) {
auto task = taskQueue_->take();
if (UNLIKELY(task.poison)) {
CHECK(threadsToStop_-- > 0);
for (auto& o : observers_) {
o->threadStopped(thread.get());
}
stoppedThreads_.add(thread);
return;
} else {
runTask(thread, std::move(task));
}
if (UNLIKELY(threadsToStop_ > 0 && !isJoin_)) {
if (--threadsToStop_ >= 0) {
stoppedThreads_.add(thread);
return;
} else {
threadsToStop_++;
}
}
}
}
void CPUThreadPoolExecutor::stopThreads(size_t n) {
CHECK(stoppedThreads_.size() == 0);
threadsToStop_ = n;
for (size_t i = 0; i < n; i++) {
taskQueue_->addWithPriority(CPUTask(), Executor::LO_PRI);
}
}
uint64_t CPUThreadPoolExecutor::getPendingTaskCount() {
return taskQueue_->size();
}
}} // folly::wangle
folly/wangle/concurrent/CPUThreadPoolExecutor.h deleted 100644 → 0
View file @ a716b86b
/*
* Copyright 2015 Facebook, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#pragma once
#include <folly/wangle/concurrent/ThreadPoolExecutor.h>
namespace folly { namespace wangle {
class CPUThreadPoolExecutor : public ThreadPoolExecutor {
public:
struct CPUTask;
CPUThreadPoolExecutor(
size_t numThreads,
std::unique_ptr<BlockingQueue<CPUTask>> taskQueue,
std::shared_ptr<ThreadFactory> threadFactory =
std::make_shared<NamedThreadFactory>("CPUThreadPool"));
explicit CPUThreadPoolExecutor(size_t numThreads);
CPUThreadPoolExecutor(
size_t numThreads,
std::shared_ptr<ThreadFactory> threadFactory);
CPUThreadPoolExecutor(
size_t numThreads,
int8_t numPriorities,
std::shared_ptr<ThreadFactory> threadFactory =
std::make_shared<NamedThreadFactory>("CPUThreadPool"));
CPUThreadPoolExecutor(
size_t numThreads,
int8_t numPriorities,
size_t maxQueueSize,
std::shared_ptr<ThreadFactory> threadFactory =
std::make_shared<NamedThreadFactory>("CPUThreadPool"));
~CPUThreadPoolExecutor();
void add(Func func) override;
void add(
Func func,
std::chrono::milliseconds expiration,
Func expireCallback = nullptr) override;
void addWithPriority(Func func, int8_t priority) override;
void add(
Func func,
int8_t priority,
std::chrono::milliseconds expiration,
Func expireCallback = nullptr);
uint8_t getNumPriorities() const override;
struct CPUTask : public ThreadPoolExecutor::Task {
// Must be noexcept move constructible so it can be used in MPMCQueue
explicit CPUTask(
Func&& f,
std::chrono::milliseconds expiration,
Func&& expireCallback)
: Task(std::move(f), expiration, std::move(expireCallback)),
poison(false) {}
CPUTask()
: Task(nullptr, std::chrono::milliseconds(0), nullptr),
poison(true) {}
CPUTask(CPUTask&& o) noexcept : Task(std::move(o)), poison(o.poison) {}
CPUTask(const CPUTask&) = default;
CPUTask& operator=(const CPUTask&) = default;
bool poison;
};
static const size_t kDefaultMaxQueueSize;
protected:
BlockingQueue<CPUTask>* getTaskQueue();
private:
void threadRun(ThreadPtr thread) override;
void stopThreads(size_t n) override;
uint64_t getPendingTaskCount() override;
std::unique_ptr<BlockingQueue<CPUTask>> taskQueue_;
std::atomic<ssize_t> threadsToStop_{0};
};
}} // folly::wangle
folly/wangle/concurrent/Codel.cpp deleted 100644 → 0
View file @ a716b86b
/*
* Copyright 2015 Facebook, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <folly/wangle/concurrent/Codel.h>
#include <algorithm>
#include <math.h>
#ifndef NO_LIB_GFLAGS
#include <gflags/gflags.h>
DEFINE_int32(codel_interval, 100,
"Codel default interval time in ms");
DEFINE_int32(codel_target_delay, 5,
"Target codel queueing delay in ms");
#endif
namespace folly { namespace wangle {
#ifdef NO_LIB_GFLAGS
int32_t FLAGS_codel_interval = 100;
int32_t FLAGS_codel_target_delay = 5;
#endif
Codel::Codel()
: codelMinDelay_(0),
codelIntervalTime_(std::chrono::steady_clock::now()),
codelResetDelay_(true),
overloaded_(false) {}
bool Codel::overloaded(std::chrono::microseconds delay) {
bool ret = false;
auto now = std::chrono::steady_clock::now();
// Avoid another thread updating the value at the same time we are using it
// to calculate the overloaded state
auto minDelay = codelMinDelay_;
if (now > codelIntervalTime_ &&
(!codelResetDelay_.load(std::memory_order_acquire)
&& !codelResetDelay_.exchange(true))) {
codelIntervalTime_ = now + std::chrono::milliseconds(FLAGS_codel_interval);
if (minDelay > std::chrono::milliseconds(FLAGS_codel_target_delay)) {
overloaded_ = true;
} else {
overloaded_ = false;
}
}
// Care must be taken that only a single thread resets codelMinDelay_,
// and that it happens after the interval reset above
if (codelResetDelay_.load(std::memory_order_acquire) &&
codelResetDelay_.exchange(false)) {
codelMinDelay_ = delay;
// More than one request must come in during an interval before codel
// starts dropping requests
return false;
} else if(delay < codelMinDelay_) {
codelMinDelay_ = delay;
}
if (overloaded_ &&
delay > std::chrono::milliseconds(FLAGS_codel_target_delay * 2)) {
ret = true;
}
return ret;
}
int Codel::getLoad() {
return std::min(100, (int)codelMinDelay_.count() /
(2 * FLAGS_codel_target_delay));
}
int Codel::getMinDelay() {
return (int) codelMinDelay_.count();
}
}} //namespace
folly/wangle/concurrent/Codel.h deleted 100644 → 0
View file @ a716b86b
/*
* Copyright 2015 Facebook, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#pragma once
#include <atomic>
#include <chrono>
namespace folly { namespace wangle {
/* Codel algorithm implementation:
* http://en.wikipedia.org/wiki/CoDel
*
* Algorithm modified slightly: Instead of changing the interval time
* based on the average min delay, instead we use an alternate timeout
* for each task if the min delay during the interval period is too
* high.
*
* This was found to have better latency metrics than changing the
* window size, since we can communicate with the sender via thrift
* instead of only via the tcp window size congestion control, as in TCP.
*/
class Codel {
public:
Codel();
// Given a delay, returns wether the codel algorithm would
// reject a queued request with this delay.
//
// Internally, it also keeps track of the interval
bool overloaded(std::chrono::microseconds delay);
// Get the queue load, as seen by the codel algorithm
// Gives a rough guess at how bad the queue delay is.
//
// Return: 0 = no delay, 100 = At the queueing limit
int getLoad();
int getMinDelay();
private:
std::chrono::microseconds codelMinDelay_;
std::chrono::time_point<std::chrono::steady_clock> codelIntervalTime_;
// flag to make overloaded() thread-safe, since we only want
// to reset the delay once per time period
std::atomic<bool> codelResetDelay_;
bool overloaded_;
};
}} // Namespace
folly/wangle/concurrent/FiberIOExecutor.h deleted 100644 → 0
View file @ a716b86b
/*
* Copyright 2015 Facebook, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#pragma once
#include <folly/experimental/fibers/FiberManagerMap.h>
#include <folly/wangle/concurrent/IOExecutor.h>
namespace folly { namespace fibers {
/**
* @class FiberIOExecutor
* @brief An IOExecutor that executes funcs under mapped fiber context
*
* A FiberIOExecutor wraps an IOExecutor, but executes funcs on the FiberManager
* mapped to the underlying IOExector's event base.
*/
class FiberIOExecutor : public folly::wangle::IOExecutor {
public:
explicit FiberIOExecutor(
const std::shared_ptr<folly::wangle::IOExecutor>& ioExecutor)
: ioExecutor_(ioExecutor) {}
virtual void add(std::function<void()> f) override {
auto eventBase = ioExecutor_->getEventBase();
getFiberManager(*eventBase).add(std::move(f));
}
virtual EventBase* getEventBase() override {
return ioExecutor_->getEventBase();
}
private:
std::shared_ptr<folly::wangle::IOExecutor> ioExecutor_;
};
}}
folly/wangle/concurrent/FutureExecutor.h deleted 100644 → 0
View file @ a716b86b
/*
* Copyright 2015 Facebook, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#pragma once
#include <folly/futures/Future.h>
namespace folly { namespace wangle {
template <typename ExecutorImpl>
class FutureExecutor : public ExecutorImpl {
public:
template <typename... Args>
explicit FutureExecutor(Args&&... args)
: ExecutorImpl(std::forward<Args>(args)...) {}
/*
* Given a function func that returns a Future<T>, adds that function to the
* contained Executor and returns a Future<T> which will be fulfilled with
* func's result once it has been executed.
*
* For example: auto f = futureExecutor.addFuture([](){
* return doAsyncWorkAndReturnAFuture();
* });
*/
template <typename F>
typename std::enable_if<isFuture<typename std::result_of<F()>::type>::value,
typename std::result_of<F()>::type>::type
addFuture(F func) {
typedef typename std::result_of<F()>::type::value_type T;
Promise<T> promise;
auto future = promise.getFuture();
auto movePromise = folly::makeMoveWrapper(std::move(promise));
auto moveFunc = folly::makeMoveWrapper(std::move(func));
ExecutorImpl::add([movePromise, moveFunc] () mutable {
(*moveFunc)().then([movePromise] (Try<T>&& t) mutable {
movePromise->setTry(std::move(t));
});
});
return future;
}
/*
* Similar to addFuture above, but takes a func that returns some non-Future
* type T.
*
* For example: auto f = futureExecutor.addFuture([]() {
* return 42;
* });
*/
template <typename F>
typename std::enable_if<!isFuture<typename std::result_of<F()>::type>::value,
Future<typename std::result_of<F()>::type>>::type
addFuture(F func) {
typedef typename std::result_of<F()>::type T;
Promise<T> promise;
auto future = promise.getFuture();
auto movePromise = folly::makeMoveWrapper(std::move(promise));
auto moveFunc = folly::makeMoveWrapper(std::move(func));
ExecutorImpl::add([movePromise, moveFunc] () mutable {
movePromise->setWith(std::move(*moveFunc));
});
return future;
}
};
}}
folly/wangle/concurrent/GlobalExecutor.cpp deleted 100644 → 0
View file @ a716b86b
/*
* Copyright 2015 Facebook, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <folly/Singleton.h>
#include <folly/wangle/concurrent/IOExecutor.h>
#include <folly/wangle/concurrent/IOThreadPoolExecutor.h>
#include <folly/futures/InlineExecutor.h>
using namespace folly;
using namespace folly::wangle;
namespace {
// lock protecting global CPU executor
struct CPUExecutorLock {};
Singleton<RWSpinLock, CPUExecutorLock> globalCPUExecutorLock;
// global CPU executor
Singleton<std::weak_ptr<Executor>> globalCPUExecutor;
// default global CPU executor is an InlineExecutor
Singleton<std::shared_ptr<InlineExecutor>> globalInlineExecutor(
[]{
return new std::shared_ptr<InlineExecutor>(
std::make_shared<InlineExecutor>());
});
// lock protecting global IO executor
struct IOExecutorLock {};
Singleton<RWSpinLock, IOExecutorLock> globalIOExecutorLock;
// global IO executor
Singleton<std::weak_ptr<IOExecutor>> globalIOExecutor;
// default global IO executor is an IOThreadPoolExecutor
Singleton<std::shared_ptr<IOThreadPoolExecutor>> globalIOThreadPool(
[]{
return new std::shared_ptr<IOThreadPoolExecutor>(
std::make_shared<IOThreadPoolExecutor>(
sysconf(_SC_NPROCESSORS_ONLN),
std::make_shared<NamedThreadFactory>("GlobalIOThreadPool")));
});
}
namespace folly { namespace wangle {
template <class Exe, class DefaultExe, class LockTag>
std::shared_ptr<Exe> getExecutor(
Singleton<std::weak_ptr<Exe>>& sExecutor,
Singleton<std::shared_ptr<DefaultExe>>& sDefaultExecutor,
Singleton<RWSpinLock, LockTag>& sExecutorLock) {
std::shared_ptr<Exe> executor;
auto singleton = sExecutor.get();
auto lock = sExecutorLock.get();
{
RWSpinLock::ReadHolder guard(lock);
if ((executor = sExecutor->lock())) {
return executor;
}
}
RWSpinLock::WriteHolder guard(lock);
executor = singleton->lock();
if (!executor) {
executor = *sDefaultExecutor.get();
*singleton = executor;
}
return executor;
}
template <class Exe, class LockTag>
void setExecutor(
std::shared_ptr<Exe> executor,
Singleton<std::weak_ptr<Exe>>& sExecutor,
Singleton<RWSpinLock, LockTag>& sExecutorLock) {
RWSpinLock::WriteHolder guard(sExecutorLock.get());
*sExecutor.get() = std::move(executor);
}
std::shared_ptr<Executor> getCPUExecutor() {
return getExecutor(
globalCPUExecutor,
globalInlineExecutor,
globalCPUExecutorLock);
}
void setCPUExecutor(std::shared_ptr<Executor> executor) {
setExecutor(
std::move(executor),
globalCPUExecutor,
globalCPUExecutorLock);
}
std::shared_ptr<IOExecutor> getIOExecutor() {
return getExecutor(
globalIOExecutor,
globalIOThreadPool,
globalIOExecutorLock);
}
void setIOExecutor(std::shared_ptr<IOExecutor> executor) {
setExecutor(
std::move(executor),
globalIOExecutor,
globalIOExecutorLock);
}
}} // folly::wangle
folly/wangle/concurrent/GlobalExecutor.h deleted 100644 → 0
View file @ a716b86b
/*
* Copyright 2015 Facebook, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#pragma once
#include <memory>
#include <folly/Executor.h>
#include <folly/wangle/concurrent/IOExecutor.h>
namespace folly { namespace wangle {
// Retrieve the global Executor. If there is none, a default InlineExecutor
// will be constructed and returned. This is named CPUExecutor to distinguish
// it from IOExecutor below and to hint that it's intended for CPU-bound tasks.
std::shared_ptr<Executor> getCPUExecutor();
// Set an Executor to be the global Executor which will be returned by
// subsequent calls to getCPUExecutor(). Takes a non-owning (weak) reference.
void setCPUExecutor(std::shared_ptr<Executor> executor);
// Retrieve the global IOExecutor. If there is none, a default
// IOThreadPoolExecutor will be constructed and returned.
//
// IOExecutors differ from Executors in that they drive and provide access to
// one or more EventBases.
std::shared_ptr<IOExecutor> getIOExecutor();
// Set an IOExecutor to be the global IOExecutor which will be returned by
// subsequent calls to getIOExecutor(). Takes a non-owning (weak) reference.
void setIOExecutor(std::shared_ptr<IOExecutor> executor);
}}
folly/wangle/concurrent/IOExecutor.h deleted 100644 → 0
View file @ a716b86b
/*
* Copyright 2015 Facebook, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#pragma once
#include <atomic>
#include <folly/Executor.h>
namespace folly {
class EventBase;
}
namespace folly { namespace wangle {
// An IOExecutor is an executor that operates on at least one EventBase. One of
// these EventBases should be accessible via getEventBase(). The event base
// returned by a call to getEventBase() is implementation dependent.
//
// Note that IOExecutors don't necessarily loop on the base themselves - for
// instance, EventBase itself is an IOExecutor but doesn't drive itself.
//
// Implementations of IOExecutor are eligible to become the global IO executor,
// returned on every call to getIOExecutor(), via setIOExecutor().
// These functions are declared in GlobalExecutor.h
//
// If getIOExecutor is called and none has been set, a default global
// IOThreadPoolExecutor will be created and returned.
class IOExecutor : public virtual Executor {
public:
virtual ~IOExecutor() {}
virtual EventBase* getEventBase() = 0;
};
}}
folly/wangle/concurrent/IOThreadPoolExecutor.cpp deleted 100644 → 0
View file @ a716b86b
/*
* Copyright 2015 Facebook, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <folly/wangle/concurrent/IOThreadPoolExecutor.h>
#include <folly/MoveWrapper.h>
#include <glog/logging.h>
#include <folly/detail/MemoryIdler.h>
namespace folly { namespace wangle {
using folly::detail::MemoryIdler;
/* Class that will free jemalloc caches and madvise the stack away
* if the event loop is unused for some period of time
*/
class MemoryIdlerTimeout
: public AsyncTimeout , public EventBase::LoopCallback {
public:
explicit MemoryIdlerTimeout(EventBase* b) : AsyncTimeout(b), base_(b) {}
virtual void timeoutExpired() noexcept {
idled = true;
}
virtual void runLoopCallback() noexcept {
if (idled) {
MemoryIdler::flushLocalMallocCaches();
MemoryIdler::unmapUnusedStack(MemoryIdler::kDefaultStackToRetain);
idled = false;
} else {
std::chrono::steady_clock::duration idleTimeout =
MemoryIdler::defaultIdleTimeout.load(
std::memory_order_acquire);
idleTimeout = MemoryIdler::getVariationTimeout(idleTimeout);
scheduleTimeout(std::chrono::duration_cast<std::chrono::milliseconds>(
idleTimeout).count());
}
// reschedule this callback for the next event loop.
base_->runBeforeLoop(this);
}
private:
EventBase* base_;
bool idled{false};
} ;
IOThreadPoolExecutor::IOThreadPoolExecutor(
size_t numThreads,
std::shared_ptr<ThreadFactory> threadFactory,
EventBaseManager* ebm)
: ThreadPoolExecutor(numThreads, std::move(threadFactory)),
nextThread_(0),
eventBaseManager_(ebm) {
addThreads(numThreads);
CHECK(threadList_.get().size() == numThreads);
}
IOThreadPoolExecutor::~IOThreadPoolExecutor() {
stop();
}
void IOThreadPoolExecutor::add(Func func) {
add(std::move(func), std::chrono::milliseconds(0));
}
void IOThreadPoolExecutor::add(
Func func,
std::chrono::milliseconds expiration,
Func expireCallback) {
RWSpinLock::ReadHolder{&threadListLock_};
if (threadList_.get().empty()) {
throw std::runtime_error("No threads available");
}
auto ioThread = pickThread();
auto moveTask = folly::makeMoveWrapper(
Task(std::move(func), expiration, std::move(expireCallback)));
auto wrappedFunc = [ioThread, moveTask] () mutable {
runTask(ioThread, std::move(*moveTask));
ioThread->pendingTasks--;
};
ioThread->pendingTasks++;
if (!ioThread->eventBase->runInEventBaseThread(std::move(wrappedFunc))) {
ioThread->pendingTasks--;
throw std::runtime_error("Unable to run func in event base thread");
}
}
std::shared_ptr<IOThreadPoolExecutor::IOThread>
IOThreadPoolExecutor::pickThread() {
if (*thisThread_) {
return *thisThread_;
}
auto thread = threadList_.get()[nextThread_++ % threadList_.get().size()];
return std::static_pointer_cast<IOThread>(thread);
}
EventBase* IOThreadPoolExecutor::getEventBase() {
return pickThread()->eventBase;
}
EventBase* IOThreadPoolExecutor::getEventBase(
ThreadPoolExecutor::ThreadHandle* h) {
auto thread = dynamic_cast<IOThread*>(h);
if (thread) {
return thread->eventBase;
}
return nullptr;
}
EventBaseManager* IOThreadPoolExecutor::getEventBaseManager() {
return eventBaseManager_;
}
std::shared_ptr<ThreadPoolExecutor::Thread>
IOThreadPoolExecutor::makeThread() {
return std::make_shared<IOThread>(this);
}
void IOThreadPoolExecutor::threadRun(ThreadPtr thread) {
const auto ioThread = std::static_pointer_cast<IOThread>(thread);
ioThread->eventBase = eventBaseManager_->getEventBase();
thisThread_.reset(new std::shared_ptr<IOThread>(ioThread));
auto idler = new MemoryIdlerTimeout(ioThread->eventBase);
ioThread->eventBase->runBeforeLoop(idler);
thread->startupBaton.post();
while (ioThread->shouldRun) {
ioThread->eventBase->loopForever();
}
if (isJoin_) {
while (ioThread->pendingTasks > 0) {
ioThread->eventBase->loopOnce();
}
}
stoppedThreads_.add(ioThread);
}
// threadListLock_ is writelocked
void IOThreadPoolExecutor::stopThreads(size_t n) {
for (size_t i = 0; i < n; i++) {
const auto ioThread = std::static_pointer_cast<IOThread>(
threadList_.get()[i]);
for (auto& o : observers_) {
o->threadStopped(ioThread.get());
}
ioThread->shouldRun = false;
ioThread->eventBase->terminateLoopSoon();
}
}
// threadListLock_ is readlocked
uint64_t IOThreadPoolExecutor::getPendingTaskCount() {
uint64_t count = 0;
for (const auto& thread : threadList_.get()) {
auto ioThread = std::static_pointer_cast<IOThread>(thread);
size_t pendingTasks = ioThread->pendingTasks;
if (pendingTasks > 0 && !ioThread->idle) {
pendingTasks--;
}
count += pendingTasks;
}
return count;
}
}} // folly::wangle
folly/wangle/concurrent/IOThreadPoolExecutor.h deleted 100644 → 0
View file @ a716b86b
/*
* Copyright 2015 Facebook, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#pragma once
#include <folly/io/async/EventBaseManager.h>
#include <folly/wangle/concurrent/IOExecutor.h>
#include <folly/wangle/concurrent/ThreadPoolExecutor.h>
namespace folly { namespace wangle {
// N.B. For this thread pool, stop() behaves like join() because outstanding
// tasks belong to the event base and will be executed upon its destruction.
class IOThreadPoolExecutor : public ThreadPoolExecutor, public IOExecutor {
public:
explicit IOThreadPoolExecutor(
size_t numThreads,
std::shared_ptr<ThreadFactory> threadFactory =
std::make_shared<NamedThreadFactory>("IOThreadPool"),
EventBaseManager* ebm = folly::EventBaseManager::get());
~IOThreadPoolExecutor();
void add(Func func) override;
void add(
Func func,
std::chrono::milliseconds expiration,
Func expireCallback = nullptr) override;
EventBase* getEventBase() override;
static EventBase* getEventBase(ThreadPoolExecutor::ThreadHandle*);
EventBaseManager* getEventBaseManager();
private:
struct FOLLY_ALIGN_TO_AVOID_FALSE_SHARING IOThread : public Thread {
IOThread(IOThreadPoolExecutor* pool)
: Thread(pool),
shouldRun(true),
pendingTasks(0) {};
std::atomic<bool> shouldRun;
std::atomic<size_t> pendingTasks;
EventBase* eventBase;
};
ThreadPtr makeThread() override;
std::shared_ptr<IOThread> pickThread();
void threadRun(ThreadPtr thread) override;
void stopThreads(size_t n) override;
uint64_t getPendingTaskCount() override;
size_t nextThread_;
ThreadLocal<std::shared_ptr<IOThread>> thisThread_;
EventBaseManager* eventBaseManager_;
};
}} // folly::wangle
folly/wangle/concurrent/LifoSemMPMCQueue.h deleted 100644 → 0
View file @ a716b86b
/*
* Copyright 2015 Facebook, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#pragma once
#include <folly/wangle/concurrent/BlockingQueue.h>
#include <folly/LifoSem.h>
#include <folly/MPMCQueue.h>
namespace folly { namespace wangle {
template <class T>
class LifoSemMPMCQueue : public BlockingQueue<T> {
public:
explicit LifoSemMPMCQueue(size_t max_capacity) : queue_(max_capacity) {}
void add(T item) override {
if (!queue_.write(std::move(item))) {
throw std::runtime_error("LifoSemMPMCQueue full, can't add item");
}
sem_.post();
}
T take() override {
T item;
while (!queue_.read(item)) {
sem_.wait();
}
return item;
}
size_t capacity() {
return queue_.capacity();
}
size_t size() override {
return queue_.size();
}
private:
LifoSem sem_;
MPMCQueue<T> queue_;
};
}} // folly::wangle
folly/wangle/concurrent/NamedThreadFactory.h deleted 100644 → 0
View file @ a716b86b
/*
* Copyright 2015 Facebook, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#pragma once
#include <atomic>
#include <string>
#include <thread>
#include <folly/wangle/concurrent/ThreadFactory.h>
#include <folly/Conv.h>
#include <folly/Range.h>
#include <folly/ThreadName.h>
namespace folly { namespace wangle {
class NamedThreadFactory : public ThreadFactory {
public:
explicit NamedThreadFactory(folly::StringPiece prefix)
: prefix_(prefix.str()), suffix_(0) {}
std::thread newThread(Func&& func) override {
auto thread = std::thread(std::move(func));
folly::setThreadName(
thread.native_handle(),
folly::to<std::string>(prefix_, suffix_++));
return thread;
}
void setNamePrefix(folly::StringPiece prefix) {
prefix_ = prefix.str();
}
std::string getNamePrefix() {
return prefix_;
}
private:
std::string prefix_;
std::atomic<uint64_t> suffix_;
};
}} // folly::wangle
folly/wangle/concurrent/PriorityLifoSemMPMCQueue.h deleted 100644 → 0
View file @ a716b86b
/*
* Copyright 2015 Facebook, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#pragma once
#include <folly/wangle/concurrent/BlockingQueue.h>
#include <folly/LifoSem.h>
#include <folly/MPMCQueue.h>
namespace folly { namespace wangle {
template <class T>
class PriorityLifoSemMPMCQueue : public BlockingQueue<T> {
public:
explicit PriorityLifoSemMPMCQueue(uint8_t numPriorities, size_t capacity) {
queues_.reserve(numPriorities);
for (int8_t i = 0; i < numPriorities; i++) {
queues_.push_back(MPMCQueue<T>(capacity));
}
}
uint8_t getNumPriorities() override {
return queues_.size();
}
// Add at medium priority by default
void add(T item) override {
addWithPriority(std::move(item), Executor::MID_PRI);
}
void addWithPriority(T item, int8_t priority) override {
int mid = getNumPriorities() / 2;
size_t queue = priority < 0 ?
std::max(0, mid + priority) :
std::min(getNumPriorities() - 1, mid + priority);
CHECK(queue < queues_.size());
if (!queues_[queue].write(std::move(item))) {
throw std::runtime_error("LifoSemMPMCQueue full, can't add item");
}
sem_.post();
}
T take() override {
T item;
while (true) {
for (auto it = queues_.rbegin(); it != queues_.rend(); it++) {
if (it->read(item)) {
return item;
}
}
sem_.wait();
}
}
size_t size() override {
size_t size = 0;
for (auto& q : queues_) {
size += q.size();
}
return size;
}
private:
LifoSem sem_;
std::vector<MPMCQueue<T>> queues_;
};
}} // folly::wangle
folly/wangle/concurrent/ThreadFactory.h deleted 100644 → 0
View file @ a716b86b
/*
* Copyright 2015 Facebook, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#pragma once
#include <folly/Executor.h>
#include <thread>
namespace folly { namespace wangle {
class ThreadFactory {
public:
virtual ~ThreadFactory() {}
virtual std::thread newThread(Func&& func) = 0;
};
}} // folly::wangle
folly/wangle/concurrent/ThreadPoolExecutor.cpp deleted 100644 → 0
View file @ a716b86b
/*
* Copyright 2015 Facebook, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <folly/wangle/concurrent/ThreadPoolExecutor.h>
namespace folly { namespace wangle {
ThreadPoolExecutor::ThreadPoolExecutor(
size_t numThreads,
std::shared_ptr<ThreadFactory> threadFactory)
: threadFactory_(std::move(threadFactory)),
taskStatsSubject_(std::make_shared<Subject<TaskStats>>()) {}
ThreadPoolExecutor::~ThreadPoolExecutor() {
CHECK(threadList_.get().size() == 0);
}
ThreadPoolExecutor::Task::Task(
Func&& func,
std::chrono::milliseconds expiration,
Func&& expireCallback)
: func_(std::move(func)),
expiration_(expiration),
expireCallback_(std::move(expireCallback)) {
// Assume that the task in enqueued on creation
enqueueTime_ = std::chrono::steady_clock::now();
}
void ThreadPoolExecutor::runTask(
const ThreadPtr& thread,
Task&& task) {
thread->idle = false;
auto startTime = std::chrono::steady_clock::now();
task.stats_.waitTime = startTime - task.enqueueTime_;
if (task.expiration_ > std::chrono::milliseconds(0) &&
task.stats_.waitTime >= task.expiration_) {
task.stats_.expired = true;
if (task.expireCallback_ != nullptr) {
task.expireCallback_();
}
} else {
try {
task.func_();
} catch (const std::exception& e) {
LOG(ERROR) << "ThreadPoolExecutor: func threw unhandled " <<
typeid(e).name() << " exception: " << e.what();
} catch (...) {
LOG(ERROR) << "ThreadPoolExecutor: func threw unhandled non-exception "
"object";
}
task.stats_.runTime = std::chrono::steady_clock::now() - startTime;
}
thread->idle = true;
thread->taskStatsSubject->onNext(std::move(task.stats_));
}
size_t ThreadPoolExecutor::numThreads() {
RWSpinLock::ReadHolder{&threadListLock_};
return threadList_.get().size();
}
void ThreadPoolExecutor::setNumThreads(size_t n) {
RWSpinLock::WriteHolder{&threadListLock_};
const auto current = threadList_.get().size();
if (n > current ) {
addThreads(n - current);
} else if (n < current) {
removeThreads(current - n, true);
}
CHECK(threadList_.get().size() == n);
}
// threadListLock_ is writelocked
void ThreadPoolExecutor::addThreads(size_t n) {
std::vector<ThreadPtr> newThreads;
for (size_t i = 0; i < n; i++) {
newThreads.push_back(makeThread());
}
for (auto& thread : newThreads) {
// TODO need a notion of failing to create the thread
// and then handling for that case
thread->handle = threadFactory_->newThread(
std::bind(&ThreadPoolExecutor::threadRun, this, thread));
threadList_.add(thread);
}
for (auto& thread : newThreads) {
thread->startupBaton.wait();
}
for (auto& o : observers_) {
for (auto& thread : newThreads) {
o->threadStarted(thread.get());
}
}
}
// threadListLock_ is writelocked
void ThreadPoolExecutor::removeThreads(size_t n, bool isJoin) {
CHECK(n <= threadList_.get().size());
CHECK(stoppedThreads_.size() == 0);
isJoin_ = isJoin;
stopThreads(n);
for (size_t i = 0; i < n; i++) {
auto thread = stoppedThreads_.take();
thread->handle.join();
threadList_.remove(thread);
}
CHECK(stoppedThreads_.size() == 0);
}
void ThreadPoolExecutor::stop() {
RWSpinLock::WriteHolder{&threadListLock_};
removeThreads(threadList_.get().size(), false);
CHECK(threadList_.get().size() == 0);
}
void ThreadPoolExecutor::join() {
RWSpinLock::WriteHolder{&threadListLock_};
removeThreads(threadList_.get().size(), true);
CHECK(threadList_.get().size() == 0);
}
ThreadPoolExecutor::PoolStats ThreadPoolExecutor::getPoolStats() {
RWSpinLock::ReadHolder{&threadListLock_};
ThreadPoolExecutor::PoolStats stats;
stats.threadCount = threadList_.get().size();
for (auto thread : threadList_.get()) {
if (thread->idle) {
stats.idleThreadCount++;
} else {
stats.activeThreadCount++;
}
}
stats.pendingTaskCount = getPendingTaskCount();
stats.totalTaskCount = stats.pendingTaskCount + stats.activeThreadCount;
return stats;
}
std::atomic<uint64_t> ThreadPoolExecutor::Thread::nextId(0);
void ThreadPoolExecutor::StoppedThreadQueue::add(
ThreadPoolExecutor::ThreadPtr item) {
std::lock_guard<std::mutex> guard(mutex_);
queue_.push(std::move(item));
sem_.post();
}
ThreadPoolExecutor::ThreadPtr ThreadPoolExecutor::StoppedThreadQueue::take() {
while(1) {
{
std::lock_guard<std::mutex> guard(mutex_);
if (queue_.size() > 0) {
auto item = std::move(queue_.front());
queue_.pop();
return item;
}
}
sem_.wait();
}
}
size_t ThreadPoolExecutor::StoppedThreadQueue::size() {
std::lock_guard<std::mutex> guard(mutex_);
return queue_.size();
}
void ThreadPoolExecutor::addObserver(std::shared_ptr<Observer> o) {
RWSpinLock::ReadHolder{&threadListLock_};
observers_.push_back(o);
for (auto& thread : threadList_.get()) {
o->threadPreviouslyStarted(thread.get());
}
}
void ThreadPoolExecutor::removeObserver(std::shared_ptr<Observer> o) {
RWSpinLock::ReadHolder{&threadListLock_};
for (auto& thread : threadList_.get()) {
o->threadNotYetStopped(thread.get());
}
for (auto it = observers_.begin(); it != observers_.end(); it++) {
if (*it == o) {
observers_.erase(it);
return;
}
}
DCHECK(false);
}
}} // folly::wangle
folly/wangle/concurrent/ThreadPoolExecutor.h deleted 100644 → 0
View file @ a716b86b
/*
* Copyright 2015 Facebook, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#pragma once
#include <folly/Executor.h>
#include <folly/wangle/concurrent/LifoSemMPMCQueue.h>
#include <folly/wangle/concurrent/NamedThreadFactory.h>
#include <folly/wangle/rx/Observable.h>
#include <folly/Baton.h>
#include <folly/Memory.h>
#include <folly/RWSpinLock.h>
#include <algorithm>
#include <mutex>
#include <queue>
#include <glog/logging.h>
namespace folly { namespace wangle {
class ThreadPoolExecutor : public virtual Executor {
public:
explicit ThreadPoolExecutor(
size_t numThreads,
std::shared_ptr<ThreadFactory> threadFactory);
~ThreadPoolExecutor();
virtual void add(Func func) override = 0;
virtual void add(
Func func,
std::chrono::milliseconds expiration,
Func expireCallback) = 0;
void setThreadFactory(std::shared_ptr<ThreadFactory> threadFactory) {
CHECK(numThreads() == 0);
threadFactory_ = std::move(threadFactory);
}
std::shared_ptr<ThreadFactory> getThreadFactory(void) {
return threadFactory_;
}
size_t numThreads();
void setNumThreads(size_t numThreads);
/*
* stop() is best effort - there is no guarantee that unexecuted tasks won't
* be executed before it returns. Specifically, IOThreadPoolExecutor's stop()
* behaves like join().
*/
void stop();
void join();
struct PoolStats {
PoolStats() : threadCount(0), idleThreadCount(0), activeThreadCount(0),
pendingTaskCount(0), totalTaskCount(0) {}
size_t threadCount, idleThreadCount, activeThreadCount;
uint64_t pendingTaskCount, totalTaskCount;
};
PoolStats getPoolStats();
struct TaskStats {
TaskStats() : expired(false), waitTime(0), runTime(0) {}
bool expired;
std::chrono::nanoseconds waitTime;
std::chrono::nanoseconds runTime;
};
Subscription<TaskStats> subscribeToTaskStats(
const ObserverPtr<TaskStats>& observer) {
return taskStatsSubject_->subscribe(observer);
}
/**
* Base class for threads created with ThreadPoolExecutor.
* Some subclasses have methods that operate on these
* handles.
*/
class ThreadHandle {
public:
virtual ~ThreadHandle() = default;
};
/**
* Observer interface for thread start/stop.
* Provides hooks so actions can be taken when
* threads are created
*/
class Observer {
public:
virtual void threadStarted(ThreadHandle*) = 0;
virtual void threadStopped(ThreadHandle*) = 0;
virtual void threadPreviouslyStarted(ThreadHandle* h) {
threadStarted(h);
}
virtual void threadNotYetStopped(ThreadHandle* h) {
threadStopped(h);
}
virtual ~Observer() = default;
};
void addObserver(std::shared_ptr<Observer>);
void removeObserver(std::shared_ptr<Observer>);
protected:
// Prerequisite: threadListLock_ writelocked
void addThreads(size_t n);
// Prerequisite: threadListLock_ writelocked
void removeThreads(size_t n, bool isJoin);
struct FOLLY_ALIGN_TO_AVOID_FALSE_SHARING Thread : public ThreadHandle {
explicit Thread(ThreadPoolExecutor* pool)
: id(nextId++),
handle(),
idle(true),
taskStatsSubject(pool->taskStatsSubject_) {}
virtual ~Thread() {}
static std::atomic<uint64_t> nextId;
uint64_t id;
std::thread handle;
bool idle;
Baton<> startupBaton;
std::shared_ptr<Subject<TaskStats>> taskStatsSubject;
};
typedef std::shared_ptr<Thread> ThreadPtr;
struct Task {
explicit Task(
Func&& func,
std::chrono::milliseconds expiration,
Func&& expireCallback);
Func func_;
TaskStats stats_;
std::chrono::steady_clock::time_point enqueueTime_;
std::chrono::milliseconds expiration_;
Func expireCallback_;
};
static void runTask(const ThreadPtr& thread, Task&& task);
// The function that will be bound to pool threads. It must call
// thread->startupBaton.post() when it's ready to consume work.
virtual void threadRun(ThreadPtr thread) = 0;
// Stop n threads and put their ThreadPtrs in the threadsStopped_ queue
// Prerequisite: threadListLock_ writelocked
virtual void stopThreads(size_t n) = 0;
// Create a suitable Thread struct
virtual ThreadPtr makeThread() {
return std::make_shared<Thread>(this);
}
// Prerequisite: threadListLock_ readlocked
virtual uint64_t getPendingTaskCount() = 0;
class ThreadList {
public:
void add(const ThreadPtr& state) {
auto it = std::lower_bound(vec_.begin(), vec_.end(), state,
// compare method is a static method of class
// and therefore cannot be inlined by compiler
// as a template predicate of the STL algorithm
// but wrapped up with the lambda function (lambda will be inlined)
// compiler can inline compare method as well
[&](const ThreadPtr& ts1, const ThreadPtr& ts2) -> bool { // inline
return compare(ts1, ts2);
});
vec_.insert(it, state);
}
void remove(const ThreadPtr& state) {
auto itPair = std::equal_range(vec_.begin(), vec_.end(), state,
// the same as above
[&](const ThreadPtr& ts1, const ThreadPtr& ts2) -> bool { // inline
return compare(ts1, ts2);
});
CHECK(itPair.first != vec_.end());
CHECK(std::next(itPair.first) == itPair.second);
vec_.erase(itPair.first);
}
const std::vector<ThreadPtr>& get() const {
return vec_;
}
private:
static bool compare(const ThreadPtr& ts1, const ThreadPtr& ts2) {
return ts1->id < ts2->id;
}
std::vector<ThreadPtr> vec_;
};
class StoppedThreadQueue : public BlockingQueue<ThreadPtr> {
public:
void add(ThreadPtr item) override;
ThreadPtr take() override;
size_t size() override;
private:
LifoSem sem_;
std::mutex mutex_;
std::queue<ThreadPtr> queue_;
};
std::shared_ptr<ThreadFactory> threadFactory_;
ThreadList threadList_;
RWSpinLock threadListLock_;
StoppedThreadQueue stoppedThreads_;
std::atomic<bool> isJoin_; // whether the current downsizing is a join
std::shared_ptr<Subject<TaskStats>> taskStatsSubject_;
std::vector<std::shared_ptr<Observer>> observers_;
};
}} // folly::wangle
folly/wangle/concurrent/test/CodelTest.cpp deleted 100644 → 0
View file @ a716b86b
/*
* Copyright 2015 Facebook, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <chrono>
#include <folly/wangle/concurrent/Codel.h>
#include <gtest/gtest.h>
#include <thread>
TEST(CodelTest, Basic) {
using std::chrono::milliseconds;
folly::wangle::Codel c;
std::this_thread::sleep_for(milliseconds(110));
// This interval is overloaded
EXPECT_FALSE(c.overloaded(milliseconds(100)));
std::this_thread::sleep_for(milliseconds(90));
// At least two requests must happen in an interval before they will fail
EXPECT_FALSE(c.overloaded(milliseconds(50)));
EXPECT_TRUE(c.overloaded(milliseconds(50)));
std::this_thread::sleep_for(milliseconds(110));
// Previous interval is overloaded, but 2ms isn't enough to fail
EXPECT_FALSE(c.overloaded(milliseconds(2)));
std::this_thread::sleep_for(milliseconds(90));
// 20 ms > target interval * 2
EXPECT_TRUE(c.overloaded(milliseconds(20)));
}
folly/wangle/concurrent/test/GlobalExecutorTest.cpp deleted 100644 → 0
View file @ a716b86b
/*
* Copyright 2015 Facebook, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <gtest/gtest.h>
#include <folly/wangle/concurrent/GlobalExecutor.h>
#include <folly/wangle/concurrent/IOExecutor.h>
using namespace folly::wangle;
TEST(GlobalExecutorTest, GlobalCPUExecutor) {
class DummyExecutor : public folly::Executor {
public:
void add(folly::Func f) override {
f();
count++;
}
int count{0};
};
// The default CPU executor is a synchronous inline executor, lets verify
// that work we add is executed
auto count = 0;
auto f = [&](){ count++; };
// Don't explode, we should create the default global CPUExecutor lazily here.
getCPUExecutor()->add(f);
EXPECT_EQ(1, count);
{
auto dummy = std::make_shared<DummyExecutor>();
setCPUExecutor(dummy);
getCPUExecutor()->add(f);
// Make sure we were properly installed.
EXPECT_EQ(1, dummy->count);
EXPECT_EQ(2, count);
}
// Don't explode, we should restore the default global CPUExecutor because our
// weak reference to dummy has expired
getCPUExecutor()->add(f);
EXPECT_EQ(3, count);
}
TEST(GlobalExecutorTest, GlobalIOExecutor) {
class DummyExecutor : public IOExecutor {
public:
void add(folly::Func f) override {
count++;
}
folly::EventBase* getEventBase() override {
return nullptr;
}
int count{0};
};
auto f = [](){};
// Don't explode, we should create the default global IOExecutor lazily here.
getIOExecutor()->add(f);
{
auto dummy = std::make_shared<DummyExecutor>();
setIOExecutor(dummy);
getIOExecutor()->add(f);
// Make sure we were properly installed.
EXPECT_EQ(1, dummy->count);
}
// Don't explode, we should restore the default global IOExecutor because our
// weak reference to dummy has expired
getIOExecutor()->add(f);
}
folly/wangle/concurrent/test/ThreadPoolExecutorTest.cpp deleted 100644 → 0
View file @ a716b86b
/*
* Copyright 2015 Facebook, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <folly/wangle/concurrent/FutureExecutor.h>
#include <folly/wangle/concurrent/ThreadPoolExecutor.h>
#include <folly/wangle/concurrent/CPUThreadPoolExecutor.h>
#include <folly/wangle/concurrent/IOThreadPoolExecutor.h>
#include <glog/logging.h>
#include <gtest/gtest.h>
using namespace folly;
using namespace folly::wangle;
using namespace std::chrono;
static folly::Func burnMs(uint64_t ms) {
return [ms]() { std::this_thread::sleep_for(milliseconds(ms)); };
}
template <class TPE>
static void basic() {
// Create and destroy
TPE tpe(10);
}
TEST(ThreadPoolExecutorTest, CPUBasic) {
basic<CPUThreadPoolExecutor>();
}
TEST(IOThreadPoolExecutorTest, IOBasic) {
basic<IOThreadPoolExecutor>();
}
template <class TPE>
static void resize() {
TPE tpe(100);
EXPECT_EQ(100, tpe.numThreads());
tpe.setNumThreads(50);
EXPECT_EQ(50, tpe.numThreads());
tpe.setNumThreads(150);
EXPECT_EQ(150, tpe.numThreads());
}
TEST(ThreadPoolExecutorTest, CPUResize) {
resize<CPUThreadPoolExecutor>();
}
TEST(ThreadPoolExecutorTest, IOResize) {
resize<IOThreadPoolExecutor>();
}
template <class TPE>
static void stop() {
TPE tpe(1);
std::atomic<int> completed(0);
auto f = [&](){
burnMs(10)();
completed++;
};
for (int i = 0; i < 1000; i++) {
tpe.add(f);
}
tpe.stop();
EXPECT_GT(1000, completed);
}
// IOThreadPoolExecutor's stop() behaves like join(). Outstanding tasks belong
// to the event base, will be executed upon its destruction, and cannot be
// taken back.
template <>
void stop<IOThreadPoolExecutor>() {
IOThreadPoolExecutor tpe(1);
std::atomic<int> completed(0);
auto f = [&](){
burnMs(10)();
completed++;
};
for (int i = 0; i < 10; i++) {
tpe.add(f);
}
tpe.stop();
EXPECT_EQ(10, completed);
}
TEST(ThreadPoolExecutorTest, CPUStop) {
stop<CPUThreadPoolExecutor>();
}
TEST(ThreadPoolExecutorTest, IOStop) {
stop<IOThreadPoolExecutor>();
}
template <class TPE>
static void join() {
TPE tpe(10);
std::atomic<int> completed(0);
auto f = [&](){
burnMs(1)();
completed++;
};
for (int i = 0; i < 1000; i++) {
tpe.add(f);
}
tpe.join();
EXPECT_EQ(1000, completed);
}
TEST(ThreadPoolExecutorTest, CPUJoin) {
join<CPUThreadPoolExecutor>();
}
TEST(ThreadPoolExecutorTest, IOJoin) {
join<IOThreadPoolExecutor>();
}
template <class TPE>
static void resizeUnderLoad() {
TPE tpe(10);
std::atomic<int> completed(0);
auto f = [&](){
burnMs(1)();
completed++;
};
for (int i = 0; i < 1000; i++) {
tpe.add(f);
}
tpe.setNumThreads(5);
tpe.setNumThreads(15);
tpe.join();
EXPECT_EQ(1000, completed);
}
TEST(ThreadPoolExecutorTest, CPUResizeUnderLoad) {
resizeUnderLoad<CPUThreadPoolExecutor>();
}
TEST(ThreadPoolExecutorTest, IOResizeUnderLoad) {
resizeUnderLoad<IOThreadPoolExecutor>();
}
template <class TPE>
static void poolStats() {
folly::Baton<> startBaton, endBaton;
TPE tpe(1);
auto stats = tpe.getPoolStats();
EXPECT_EQ(1, stats.threadCount);
EXPECT_EQ(1, stats.idleThreadCount);
EXPECT_EQ(0, stats.activeThreadCount);
EXPECT_EQ(0, stats.pendingTaskCount);
EXPECT_EQ(0, stats.totalTaskCount);
tpe.add([&](){ startBaton.post(); endBaton.wait(); });
tpe.add([&](){});
startBaton.wait();
stats = tpe.getPoolStats();
EXPECT_EQ(1, stats.threadCount);
EXPECT_EQ(0, stats.idleThreadCount);
EXPECT_EQ(1, stats.activeThreadCount);
EXPECT_EQ(1, stats.pendingTaskCount);
EXPECT_EQ(2, stats.totalTaskCount);
endBaton.post();
}
TEST(ThreadPoolExecutorTest, CPUPoolStats) {
poolStats<CPUThreadPoolExecutor>();
}
TEST(ThreadPoolExecutorTest, IOPoolStats) {
poolStats<IOThreadPoolExecutor>();
}
template <class TPE>
static void taskStats() {
TPE tpe(1);
std::atomic<int> c(0);
auto s = tpe.subscribeToTaskStats(
Observer<ThreadPoolExecutor::TaskStats>::create(
[&](ThreadPoolExecutor::TaskStats stats) {
int i = c++;
EXPECT_LT(milliseconds(0), stats.runTime);
if (i == 1) {
EXPECT_LT(milliseconds(0), stats.waitTime);
}
}));
tpe.add(burnMs(10));
tpe.add(burnMs(10));
tpe.join();
EXPECT_EQ(2, c);
}
TEST(ThreadPoolExecutorTest, CPUTaskStats) {
taskStats<CPUThreadPoolExecutor>();
}
TEST(ThreadPoolExecutorTest, IOTaskStats) {
taskStats<IOThreadPoolExecutor>();
}
template <class TPE>
static void expiration() {
TPE tpe(1);
std::atomic<int> statCbCount(0);
auto s = tpe.subscribeToTaskStats(
Observer<ThreadPoolExecutor::TaskStats>::create(
[&](ThreadPoolExecutor::TaskStats stats) {
int i = statCbCount++;
if (i == 0) {
EXPECT_FALSE(stats.expired);
} else if (i == 1) {
EXPECT_TRUE(stats.expired);
} else {
FAIL();
}
}));
std::atomic<int> expireCbCount(0);
auto expireCb = [&] () { expireCbCount++; };
tpe.add(burnMs(10), seconds(60), expireCb);
tpe.add(burnMs(10), milliseconds(10), expireCb);
tpe.join();
EXPECT_EQ(2, statCbCount);
EXPECT_EQ(1, expireCbCount);
}
TEST(ThreadPoolExecutorTest, CPUExpiration) {
expiration<CPUThreadPoolExecutor>();
}
TEST(ThreadPoolExecutorTest, IOExpiration) {
expiration<IOThreadPoolExecutor>();
}
template <typename TPE>
static void futureExecutor() {
FutureExecutor<TPE> fe(2);
std::atomic<int> c{0};
fe.addFuture([] () { return makeFuture<int>(42); }).then(
[&] (Try<int>&& t) {
c++;
EXPECT_EQ(42, t.value());
});
fe.addFuture([] () { return 100; }).then(
[&] (Try<int>&& t) {
c++;
EXPECT_EQ(100, t.value());
});
fe.addFuture([] () { return makeFuture(); }).then(
[&] (Try<void>&& t) {
c++;
EXPECT_NO_THROW(t.value());
});
fe.addFuture([] () { return; }).then(
[&] (Try<void>&& t) {
c++;
EXPECT_NO_THROW(t.value());
});
fe.addFuture([] () { throw std::runtime_error("oops"); }).then(
[&] (Try<void>&& t) {
c++;
EXPECT_THROW(t.value(), std::runtime_error);
});
// Test doing actual async work
folly::Baton<> baton;
fe.addFuture([&] () {
auto p = std::make_shared<Promise<int>>();
std::thread t([p](){
burnMs(10)();
p->setValue(42);
});
t.detach();
return p->getFuture();
}).then([&] (Try<int>&& t) {
EXPECT_EQ(42, t.value());
c++;
baton.post();
});
baton.wait();
fe.join();
EXPECT_EQ(6, c);
}
TEST(ThreadPoolExecutorTest, CPUFuturePool) {
futureExecutor<CPUThreadPoolExecutor>();
}
TEST(ThreadPoolExecutorTest, IOFuturePool) {
futureExecutor<IOThreadPoolExecutor>();
}
TEST(ThreadPoolExecutorTest, PriorityPreemptionTest) {
bool tookLopri = false;
auto completed = 0;
auto hipri = [&] {
EXPECT_FALSE(tookLopri);
completed++;
};
auto lopri = [&] {
tookLopri = true;
completed++;
};
CPUThreadPoolExecutor pool(0, 2);
for (int i = 0; i < 50; i++) {
pool.addWithPriority(lopri, Executor::LO_PRI);
}
for (int i = 0; i < 50; i++) {
pool.addWithPriority(hipri, Executor::HI_PRI);
}
pool.setNumThreads(1);
pool.join();
EXPECT_EQ(100, completed);
}
class TestObserver : public ThreadPoolExecutor::Observer {
public:
void threadStarted(ThreadPoolExecutor::ThreadHandle*) {
threads_++;
}
void threadStopped(ThreadPoolExecutor::ThreadHandle*) {
threads_--;
}
void threadPreviouslyStarted(ThreadPoolExecutor::ThreadHandle*) {
threads_++;
}
void threadNotYetStopped(ThreadPoolExecutor::ThreadHandle*) {
threads_--;
}
void checkCalls() {
ASSERT_EQ(threads_, 0);
}
private:
std::atomic<int> threads_{0};
};
TEST(ThreadPoolExecutorTest, IOObserver) {
auto observer = std::make_shared<TestObserver>();
{
IOThreadPoolExecutor exe(10);
exe.addObserver(observer);
exe.setNumThreads(3);
exe.setNumThreads(0);
exe.setNumThreads(7);
exe.removeObserver(observer);
exe.setNumThreads(10);
}
observer->checkCalls();
}
TEST(ThreadPoolExecutorTest, CPUObserver) {
auto observer = std::make_shared<TestObserver>();
{
CPUThreadPoolExecutor exe(10);
exe.addObserver(observer);
exe.setNumThreads(3);
exe.setNumThreads(0);
exe.setNumThreads(7);
exe.removeObserver(observer);
exe.setNumThreads(10);
}
observer->checkCalls();
}
TEST(ThreadPoolExecutorTest, AddWithPriority) {
std::atomic_int c{0};
auto f = [&]{ c++; };
// IO exe doesn't support priorities
IOThreadPoolExecutor ioExe(10);
EXPECT_THROW(ioExe.addWithPriority(f, 0), std::runtime_error);
CPUThreadPoolExecutor cpuExe(10, 3);
cpuExe.addWithPriority(f, -1);
cpuExe.addWithPriority(f, 0);
cpuExe.addWithPriority(f, 1);
cpuExe.addWithPriority(f, -2); // will add at the lowest priority
cpuExe.addWithPriority(f, 2); // will add at the highest priority
cpuExe.addWithPriority(f, Executor::LO_PRI);
cpuExe.addWithPriority(f, Executor::HI_PRI);
cpuExe.join();
EXPECT_EQ(7, c);
}
folly/wangle/rx/Dummy.cpp deleted 100644 → 0
View file @ a716b86b
/*
* Copyright 2015 Facebook, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
// fbbuild is too dumb to know that .h files in the directory affect
// our project, unless we have a .cpp file in the target, in the same
// directory.
folly/wangle/rx/Observable.h deleted 100644 → 0
View file @ a716b86b
/*
* Copyright 2015 Facebook, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#pragma once
#include <folly/wangle/rx/types.h> // must come first
#include <folly/wangle/rx/Subject.h>
#include <folly/wangle/rx/Subscription.h>
#include <folly/RWSpinLock.h>
#include <folly/SmallLocks.h>
#include <folly/ThreadLocal.h>
#include <folly/small_vector.h>
#include <folly/Executor.h>
#include <folly/Memory.h>
#include <map>
#include <memory>
namespace folly { namespace wangle {
template <class T, size_t InlineObservers>
class Observable {
public:
Observable() : nextSubscriptionId_{1} {}
// TODO perhaps we want to provide this #5283229
Observable(Observable&& other) = delete;
virtual ~Observable() {
if (unsubscriber_) {
unsubscriber_->disable();
}
}
// The next three methods subscribe the given Observer to this Observable.
//
// If these are called within an Observer callback, the new observer will not
// get the current update but will get subsequent updates.
//
// subscribe() returns a Subscription object. The observer will continue to
// get updates until the Subscription is destroyed.
//
// observe(ObserverPtr<T>) creates an indefinite subscription
//
// observe(Observer<T>*) also creates an indefinite subscription, but the
// caller is responsible for ensuring that the given Observer outlives this
// Observable. This might be useful in high performance environments where
// allocations must be kept to a minimum. Template parameter InlineObservers
// specifies how many observers can been subscribed inline without any
// allocations (it's just the size of a folly::small_vector).
virtual Subscription<T> subscribe(ObserverPtr<T> observer) {
return subscribeImpl(observer, false);
}
virtual void observe(ObserverPtr<T> observer) {
subscribeImpl(observer, true);
}
virtual void observe(Observer<T>* observer) {
if (inCallback_ && *inCallback_) {
if (!newObservers_) {
newObservers_.reset(new ObserverList());
}
newObservers_->push_back(observer);
} else {
RWSpinLock::WriteHolder{&observersLock_};
observers_.push_back(observer);
}
}
// TODO unobserve(ObserverPtr<T>), unobserve(Observer<T>*)
/// Returns a new Observable that will call back on the given Scheduler.
/// The returned Observable must outlive the parent Observable.
// This and subscribeOn should maybe just be a first-class feature of an
// Observable, rather than making new ones whose lifetimes are tied to their
// parents. In that case it'd return a reference to this object for
// chaining.
ObservablePtr<T> observeOn(SchedulerPtr scheduler) {
// you're right Hannes, if we have Observable::create we don't need this
// helper class.
struct ViaSubject : public Observable<T>
{
ViaSubject(SchedulerPtr sched,
Observable* obs)
: scheduler_(sched), observable_(obs)
{}
Subscription<T> subscribe(ObserverPtr<T> o) override {
return observable_->subscribe(
Observer<T>::create(
[=](T val) { scheduler_->add([o, val] { o->onNext(val); }); },
[=](Error e) { scheduler_->add([o, e] { o->onError(e); }); },
[=]() { scheduler_->add([o] { o->onCompleted(); }); }));
}
protected:
SchedulerPtr scheduler_;
Observable* observable_;
};
return std::make_shared<ViaSubject>(scheduler, this);
}
/// Returns a new Observable that will subscribe to this parent Observable
/// via the given Scheduler. This can be subtle and confusing at first, see
/// http://www.introtorx.com/Content/v1.0.10621.0/15_SchedulingAndThreading.html#SubscribeOnObserveOn
std::unique_ptr<Observable> subscribeOn(SchedulerPtr scheduler) {
struct Subject_ : public Subject<T> {
public:
Subject_(SchedulerPtr s, Observable* o) : scheduler_(s), observable_(o) {
}
Subscription<T> subscribe(ObserverPtr<T> o) {
scheduler_->add([=] {
observable_->subscribe(o);
});
return Subscription<T>(nullptr, 0); // TODO
}
protected:
SchedulerPtr scheduler_;
Observable* observable_;
};
return folly::make_unique<Subject_>(scheduler, this);
}
protected:
// Safely execute an operation on each observer. F must take a single
// Observer<T>* as its argument.
template <class F>
void forEachObserver(F f) {
if (UNLIKELY(!inCallback_)) {
inCallback_.reset(new bool{false});
}
CHECK(!(*inCallback_));
*inCallback_ = true;
{
RWSpinLock::ReadHolder rh(observersLock_);
for (auto o : observers_) {
f(o);
}
for (auto& kv : subscribers_) {
f(kv.second.get());
}
}
if (UNLIKELY((newObservers_ && !newObservers_->empty()) ||
(newSubscribers_ && !newSubscribers_->empty()) ||
(oldSubscribers_ && !oldSubscribers_->empty()))) {
{
RWSpinLock::WriteHolder wh(observersLock_);
if (newObservers_) {
for (auto observer : *(newObservers_)) {
observers_.push_back(observer);
}
newObservers_->clear();
}
if (newSubscribers_) {
for (auto& kv : *(newSubscribers_)) {
subscribers_.insert(std::move(kv));
}
newSubscribers_->clear();
}
if (oldSubscribers_) {
for (auto id : *(oldSubscribers_)) {
subscribers_.erase(id);
}
oldSubscribers_->clear();
}
}
}
*inCallback_ = false;
}
private:
Subscription<T> subscribeImpl(ObserverPtr<T> observer, bool indefinite) {
auto subscription = makeSubscription(indefinite);
typename SubscriberMap::value_type kv{subscription.id_, std::move(observer)};
if (inCallback_ && *inCallback_) {
if (!newSubscribers_) {
newSubscribers_.reset(new SubscriberMap());
}
newSubscribers_->insert(std::move(kv));
} else {
RWSpinLock::WriteHolder{&observersLock_};
subscribers_.insert(std::move(kv));
}
return subscription;
}
class Unsubscriber {
public:
explicit Unsubscriber(Observable* observable) : observable_(observable) {
CHECK(observable_);
}
void unsubscribe(uint64_t id) {
CHECK(id > 0);
RWSpinLock::ReadHolder guard(lock_);
if (observable_) {
observable_->unsubscribe(id);
}
}
void disable() {
RWSpinLock::WriteHolder guard(lock_);
observable_ = nullptr;
}
private:
RWSpinLock lock_;
Observable* observable_;
};
std::shared_ptr<Unsubscriber> unsubscriber_{nullptr};
MicroSpinLock unsubscriberLock_{0};
friend class Subscription<T>;
void unsubscribe(uint64_t id) {
if (inCallback_ && *inCallback_) {
if (!oldSubscribers_) {
oldSubscribers_.reset(new std::vector<uint64_t>());
}
if (newSubscribers_) {
auto it = newSubscribers_->find(id);
if (it != newSubscribers_->end()) {
newSubscribers_->erase(it);
return;
}
}
oldSubscribers_->push_back(id);
} else {
RWSpinLock::WriteHolder{&observersLock_};
subscribers_.erase(id);
}
}
Subscription<T> makeSubscription(bool indefinite) {
if (indefinite) {
return Subscription<T>(nullptr, nextSubscriptionId_++);
} else {
if (!unsubscriber_) {
std::lock_guard<MicroSpinLock> guard(unsubscriberLock_);
if (!unsubscriber_) {
unsubscriber_ = std::make_shared<Unsubscriber>(this);
}
}
return Subscription<T>(unsubscriber_, nextSubscriptionId_++);
}
}
std::atomic<uint64_t> nextSubscriptionId_;
RWSpinLock observersLock_;
folly::ThreadLocalPtr<bool> inCallback_;
typedef folly::small_vector<Observer<T>*, InlineObservers> ObserverList;
ObserverList observers_;
folly::ThreadLocalPtr<ObserverList> newObservers_;
typedef std::map<uint64_t, ObserverPtr<T>> SubscriberMap;
SubscriberMap subscribers_;
folly::ThreadLocalPtr<SubscriberMap> newSubscribers_;
folly::ThreadLocalPtr<std::vector<uint64_t>> oldSubscribers_;
};
}}
folly/wangle/rx/Observer.h deleted 100644 → 0
View file @ a716b86b
/*
* Copyright 2015 Facebook, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#pragma once
#include <folly/wangle/rx/types.h> // must come first
#include <functional>
#include <memory>
#include <stdexcept>
#include <folly/Memory.h>
namespace folly { namespace wangle {
template <class T> struct FunctionObserver;
/// Observer interface. You can subclass it, or you can just use create()
/// to use std::functions.
template <class T>
struct Observer {
// These are what it means to be an Observer.
virtual void onNext(const T&) = 0;
virtual void onError(Error) = 0;
virtual void onCompleted() = 0;
virtual ~Observer() = default;
/// Create an Observer with std::function callbacks. Handy to make ad-hoc
/// Observers with lambdas.
///
/// Templated for maximum perfect forwarding flexibility, but ultimately
/// whatever you pass in has to implicitly become a std::function for the
/// same signature as onNext(), onError(), and onCompleted() respectively.
/// (see the FunctionObserver typedefs)
template <class N, class E, class C>
static std::unique_ptr<Observer> create(
N&& onNextFn, E&& onErrorFn, C&& onCompletedFn)
{
return folly::make_unique<FunctionObserver<T>>(
std::forward<N>(onNextFn),
std::forward<E>(onErrorFn),
std::forward<C>(onCompletedFn));
}
/// Create an Observer with only onNext and onError callbacks.
/// onCompleted will just be a no-op.
template <class N, class E>
static std::unique_ptr<Observer> create(N&& onNextFn, E&& onErrorFn) {
return folly::make_unique<FunctionObserver<T>>(
std::forward<N>(onNextFn),
std::forward<E>(onErrorFn),
nullptr);
}
/// Create an Observer with only an onNext callback.
/// onError and onCompleted will just be no-ops.
template <class N>
static std::unique_ptr<Observer> create(N&& onNextFn) {
return folly::make_unique<FunctionObserver<T>>(
std::forward<N>(onNextFn),
nullptr,
nullptr);
}
};
/// An observer that uses std::function callbacks. You don't really want to
/// make one of these directly - instead use the Observer::create() methods.
template <class T>
struct FunctionObserver : public Observer<T> {
typedef std::function<void(const T&)> OnNext;
typedef std::function<void(Error)> OnError;
typedef std::function<void()> OnCompleted;
/// We don't need any fancy overloads of this constructor because that's
/// what Observer::create() is for.
template <class N = OnNext, class E = OnError, class C = OnCompleted>
FunctionObserver(N&& n, E&& e, C&& c)
: onNext_(std::forward<N>(n)),
onError_(std::forward<E>(e)),
onCompleted_(std::forward<C>(c))
{}
void onNext(const T& val) override {
if (onNext_) onNext_(val);
}
void onError(Error e) override {
if (onError_) onError_(e);
}
void onCompleted() override {
if (onCompleted_) onCompleted_();
}
protected:
OnNext onNext_;
OnError onError_;
OnCompleted onCompleted_;
};
}}
folly/wangle/rx/README.md deleted 100644 → 0
View file @ a716b86b
Rx is a pattern for "functional reactive programming" that started at
Microsoft in C#, and has been reimplemented in various languages, notably
RxJava for JVM languages.
It is basically the plural of Futures (a la Wangle).
```
singular | plural
+---------------------------------+-----------------------------------
sync | Foo getData() | std::vector<Foo> getData()
async | wangle::Future<Foo> getData() | wangle::Observable<Foo> getData()
```
For more on Rx, I recommend these resources:
Netflix blog post (RxJava): http://techblog.netflix.com/2013/02/rxjava-netflix-api.html
Introduction to Rx eBook (C#): http://www.introtorx.com/content/v1.0.10621.0/01_WhyRx.html
The RxJava wiki: https://github.com/Netflix/RxJava/wiki
Netflix QCon presentation: http://www.infoq.com/presentations/netflix-functional-rx
https://rx.codeplex.com/
There are open source C++ implementations, I haven't looked at them. They
might be the best way to go rather than writing it NIH-style. I mostly did it
as an exercise, to think through how closely we might want to integrate
something like this with Wangle, and to get a feel for how it works in C++.
I haven't even tried to support move-only data in this version. I'm on the
fence about the usage of shared_ptr. Subject is underdeveloped. A whole rich
set of operations is obviously missing. I haven't decided how to handle
subscriptions (and therefore cancellation), but I'm pretty sure C#'s
"Disposable" is thoroughly un-C++ (opposite of RAII). So for now subscribe
returns nothing at all and you can't cancel anything ever. The whole thing is
probably riddled with lifetime corner case bugs that will come out like a
swarm of angry bees as soon as someone tries an infinite sequence, or tries to
partially observe a long sequence. I'm pretty sure subscribeOn has a bug that
I haven't tracked down yet.
folly/wangle/rx/Subject.h deleted 100644 → 0
View file @ a716b86b
/*
* Copyright 2015 Facebook, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#pragma once
#include <folly/wangle/rx/types.h> // must come first
#include <folly/wangle/rx/Observable.h>
#include <folly/wangle/rx/Observer.h>
namespace folly { namespace wangle {
/// Subject interface. A Subject is both an Observable and an Observer. There
/// is a default implementation of the Observer methods that just forwards the
/// observed events to the Subject's observers.
template <class T>
struct Subject : public Observable<T>, public Observer<T> {
void onNext(const T& val) override {
this->forEachObserver([&](Observer<T>* o){
o->onNext(val);
});
}
void onError(Error e) override {
this->forEachObserver([&](Observer<T>* o){
o->onError(e);
});
}
void onCompleted() override {
this->forEachObserver([](Observer<T>* o){
o->onCompleted();
});
}
};
}}
folly/wangle/rx/Subscription.h deleted 100644 → 0
View file @ a716b86b
/*
* Copyright 2015 Facebook, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#pragma once
#include <folly/wangle/rx/types.h> // must come first
#include <folly/wangle/rx/Observable.h>
namespace folly { namespace wangle {
template <class T>
class Subscription {
public:
Subscription() {}
Subscription(const Subscription&) = delete;
Subscription(Subscription&& other) noexcept {
*this = std::move(other);
}
Subscription& operator=(Subscription&& other) noexcept {
unsubscribe();
unsubscriber_ = std::move(other.unsubscriber_);
id_ = other.id_;
other.unsubscriber_ = nullptr;
other.id_ = 0;
return *this;
}
~Subscription() {
unsubscribe();
}
private:
typedef typename Observable<T>::Unsubscriber Unsubscriber;
Subscription(std::shared_ptr<Unsubscriber> unsubscriber, uint64_t id)
: unsubscriber_(std::move(unsubscriber)), id_(id) {
CHECK(id_ > 0);
}
void unsubscribe() {
if (unsubscriber_ && id_ > 0) {
unsubscriber_->unsubscribe(id_);
id_ = 0;
unsubscriber_ = nullptr;
}
}
std::shared_ptr<Unsubscriber> unsubscriber_;
uint64_t id_{0};
friend class Observable<T>;
};
}}
folly/wangle/rx/test/RxBenchmark.cpp deleted 100644 → 0
View file @ a716b86b
/*
* Copyright 2015 Facebook, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <folly/Benchmark.h>
#include <folly/wangle/rx/Observer.h>
#include <folly/wangle/rx/Subject.h>
#include <gflags/gflags.h>
using namespace folly::wangle;
using folly::BenchmarkSuspender;
static std::unique_ptr<Observer<int>> makeObserver() {
return Observer<int>::create([&] (int x) {});
}
void subscribeImpl(uint iters, int N, bool countUnsubscribe) {
for (uint iter = 0; iter < iters; iter++) {
BenchmarkSuspender bs;
Subject<int> subject;
std::vector<std::unique_ptr<Observer<int>>> observers;
std::vector<Subscription<int>> subscriptions;
subscriptions.reserve(N);
for (int i = 0; i < N; i++) {
observers.push_back(makeObserver());
}
bs.dismiss();
for (int i = 0; i < N; i++) {
subscriptions.push_back(subject.subscribe(std::move(observers[i])));
}
if (countUnsubscribe) {
subscriptions.clear();
}
bs.rehire();
}
}
void subscribeAndUnsubscribe(uint iters, int N) {
subscribeImpl(iters, N, true);
}
void subscribe(uint iters, int N) {
subscribeImpl(iters, N, false);
}
void observe(uint iters, int N) {
for (uint iter = 0; iter < iters; iter++) {
BenchmarkSuspender bs;
Subject<int> subject;
std::vector<std::unique_ptr<Observer<int>>> observers;
for (int i = 0; i < N; i++) {
observers.push_back(makeObserver());
}
bs.dismiss();
for (int i = 0; i < N; i++) {
subject.observe(std::move(observers[i]));
}
bs.rehire();
}
}
void inlineObserve(uint iters, int N) {
for (uint iter = 0; iter < iters; iter++) {
BenchmarkSuspender bs;
Subject<int> subject;
std::vector<Observer<int>*> observers;
for (int i = 0; i < N; i++) {
observers.push_back(makeObserver().release());
}
bs.dismiss();
for (int i = 0; i < N; i++) {
subject.observe(observers[i]);
}
bs.rehire();
for (int i = 0; i < N; i++) {
delete observers[i];
}
}
}
void notifySubscribers(uint iters, int N) {
for (uint iter = 0; iter < iters; iter++) {
BenchmarkSuspender bs;
Subject<int> subject;
std::vector<std::unique_ptr<Observer<int>>> observers;
std::vector<Subscription<int>> subscriptions;
subscriptions.reserve(N);
for (int i = 0; i < N; i++) {
observers.push_back(makeObserver());
}
for (int i = 0; i < N; i++) {
subscriptions.push_back(subject.subscribe(std::move(observers[i])));
}
bs.dismiss();
subject.onNext(42);
bs.rehire();
}
}
void notifyInlineObservers(uint iters, int N) {
for (uint iter = 0; iter < iters; iter++) {
BenchmarkSuspender bs;
Subject<int> subject;
std::vector<Observer<int>*> observers;
for (int i = 0; i < N; i++) {
observers.push_back(makeObserver().release());
}
for (int i = 0; i < N; i++) {
subject.observe(observers[i]);
}
bs.dismiss();
subject.onNext(42);
bs.rehire();
}
}
BENCHMARK_PARAM(subscribeAndUnsubscribe, 1);
BENCHMARK_RELATIVE_PARAM(subscribe, 1);
BENCHMARK_RELATIVE_PARAM(observe, 1);
BENCHMARK_RELATIVE_PARAM(inlineObserve, 1);
BENCHMARK_DRAW_LINE();
BENCHMARK_PARAM(subscribeAndUnsubscribe, 1000);
BENCHMARK_RELATIVE_PARAM(subscribe, 1000);
BENCHMARK_RELATIVE_PARAM(observe, 1000);
BENCHMARK_RELATIVE_PARAM(inlineObserve, 1000);
BENCHMARK_DRAW_LINE();
BENCHMARK_PARAM(notifySubscribers, 1);
BENCHMARK_RELATIVE_PARAM(notifyInlineObservers, 1);
BENCHMARK_DRAW_LINE();
BENCHMARK_PARAM(notifySubscribers, 1000);
BENCHMARK_RELATIVE_PARAM(notifyInlineObservers, 1000);
int main(int argc, char** argv) {
gflags::ParseCommandLineFlags(&argc, &argv, true);
folly::runBenchmarks();
return 0;
}
folly/wangle/rx/test/RxTest.cpp deleted 100644 → 0
View file @ a716b86b
/*
* Copyright 2015 Facebook, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <folly/wangle/rx/Observer.h>
#include <folly/wangle/rx/Subject.h>
#include <gtest/gtest.h>
using namespace folly::wangle;
static std::unique_ptr<Observer<int>> incrementer(int& counter) {
return Observer<int>::create([&] (int x) {
counter++;
});
}
TEST(RxTest, Observe) {
Subject<int> subject;
auto count = 0;
subject.observe(incrementer(count));
subject.onNext(1);
EXPECT_EQ(1, count);
}
TEST(RxTest, ObserveInline) {
Subject<int> subject;
auto count = 0;
auto o = incrementer(count).release();
subject.observe(o);
subject.onNext(1);
EXPECT_EQ(1, count);
delete o;
}
TEST(RxTest, Subscription) {
Subject<int> subject;
auto count = 0;
{
auto s = subject.subscribe(incrementer(count));
subject.onNext(1);
}
// The subscription has gone out of scope so no one should get this.
subject.onNext(2);
EXPECT_EQ(1, count);
}
TEST(RxTest, SubscriptionMove) {
Subject<int> subject;
auto count = 0;
auto s = subject.subscribe(incrementer(count));
auto s2 = subject.subscribe(incrementer(count));
s2 = std::move(s);
subject.onNext(1);
Subscription<int> s3(std::move(s2));
subject.onNext(2);
EXPECT_EQ(2, count);
}
TEST(RxTest, SubscriptionOutlivesSubject) {
Subscription<int> s;
{
Subject<int> subject;
s = subject.subscribe(Observer<int>::create([](int){}));
}
// Don't explode when s is destroyed
}
TEST(RxTest, SubscribeDuringCallback) {
// A subscriber who was subscribed in the course of a callback should get
// subsequent updates but not the current update.
Subject<int> subject;
int outerCount = 0, innerCount = 0;
Subscription<int> s1, s2;
s1 = subject.subscribe(Observer<int>::create([&] (int x) {
outerCount++;
s2 = subject.subscribe(incrementer(innerCount));
}));
subject.onNext(42);
subject.onNext(0xDEADBEEF);
EXPECT_EQ(2, outerCount);
EXPECT_EQ(1, innerCount);
}
TEST(RxTest, ObserveDuringCallback) {
Subject<int> subject;
int outerCount = 0, innerCount = 0;
subject.observe(Observer<int>::create([&] (int x) {
outerCount++;
subject.observe(incrementer(innerCount));
}));
subject.onNext(42);
subject.onNext(0xDEADBEEF);
EXPECT_EQ(2, outerCount);
EXPECT_EQ(1, innerCount);
}
TEST(RxTest, ObserveInlineDuringCallback) {
Subject<int> subject;
int outerCount = 0, innerCount = 0;
auto innerO = incrementer(innerCount).release();
auto outerO = Observer<int>::create([&] (int x) {
outerCount++;
subject.observe(innerO);
}).release();
subject.observe(outerO);
subject.onNext(42);
subject.onNext(0xDEADBEEF);
EXPECT_EQ(2, outerCount);
EXPECT_EQ(1, innerCount);
delete innerO;
delete outerO;
}
TEST(RxTest, UnsubscribeDuringCallback) {
// A subscriber who was unsubscribed in the course of a callback should get
// the current update but not subsequent ones
Subject<int> subject;
int count1 = 0, count2 = 0;
auto s1 = subject.subscribe(incrementer(count1));
auto s2 = subject.subscribe(Observer<int>::create([&] (int x) {
count2++;
s1.~Subscription();
}));
subject.onNext(1);
subject.onNext(2);
EXPECT_EQ(1, count1);
EXPECT_EQ(2, count2);
}
TEST(RxTest, SubscribeUnsubscribeDuringCallback) {
// A subscriber who was subscribed and unsubscribed in the course of a
// callback should not get any updates
Subject<int> subject;
int outerCount = 0, innerCount = 0;
auto s2 = subject.subscribe(Observer<int>::create([&] (int x) {
outerCount++;
auto s2 = subject.subscribe(incrementer(innerCount));
}));
subject.onNext(1);
subject.onNext(2);
EXPECT_EQ(2, outerCount);
EXPECT_EQ(0, innerCount);
}
// Move only type
typedef std::unique_ptr<int> MO;
static MO makeMO() { return folly::make_unique<int>(1); }
template <typename T>
static ObserverPtr<T> makeMOObserver() {
return Observer<T>::create([](const T& mo) {
EXPECT_EQ(1, *mo);
});
}
TEST(RxTest, MoveOnlyRvalue) {
Subject<MO> subject;
auto s1 = subject.subscribe(makeMOObserver<MO>());
auto s2 = subject.subscribe(makeMOObserver<MO>());
auto mo = makeMO();
// Can't bind lvalues to rvalue references
// subject.onNext(mo);
subject.onNext(std::move(mo));
subject.onNext(makeMO());
}
// Copy only type
struct CO {
CO() = default;
CO(const CO&) = default;
CO(CO&&) = delete;
};
template <typename T>
static ObserverPtr<T> makeCOObserver() {
return Observer<T>::create([](const T& mo) {});
}
TEST(RxTest, CopyOnly) {
Subject<CO> subject;
auto s1 = subject.subscribe(makeCOObserver<CO>());
CO co;
subject.onNext(co);
}
folly/wangle/rx/types.h deleted 100644 → 0
View file @ a716b86b
/*
* Copyright 2015 Facebook, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#pragma once
#include <folly/ExceptionWrapper.h>
#include <folly/Executor.h>
namespace folly { namespace wangle {
typedef folly::exception_wrapper Error;
// The Executor is basically an rx Scheduler (by design). So just
// alias it.
typedef std::shared_ptr<folly::Executor> SchedulerPtr;
template <class T, size_t InlineObservers = 3> class Observable;
template <class T> struct Observer;
template <class T> struct Subject;
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>>;
}}
folly/wangle/service/ClientDispatcher.h deleted 100644 → 0
View file @ a716b86b
/*
* Copyright 2015 Facebook, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#pragma once
#include <folly/wangle/channel/Handler.h>
#include <folly/wangle/service/Service.h>
namespace folly { namespace wangle {
/**
* Dispatch a request, satisfying Promise `p` with the response;
* the returned Future is satisfied when the response is received:
* only one request is allowed at a time.
*/
template <typename Pipeline, typename Req, typename Resp = Req>
class SerialClientDispatcher : public HandlerAdapter<Req, Resp>
, public Service<Req, Resp> {
public:
typedef typename HandlerAdapter<Req, Resp>::Context Context;
void setPipeline(Pipeline* pipeline) {
pipeline_ = pipeline;
pipeline->addBack(this);
pipeline->finalize();
}
void read(Context* ctx, Req in) override {
DCHECK(p_);
p_->setValue(std::move(in));
p_ = none;
}
virtual Future<Resp> operator()(Req arg) override {
CHECK(!p_);
DCHECK(pipeline_);
p_ = Promise<Resp>();
auto f = p_->getFuture();
pipeline_->write(std::move(arg));
return f;
}
virtual Future<void> close() override {
return HandlerAdapter<Req, Resp>::close(nullptr);
}
virtual Future<void> close(Context* ctx) override {
return HandlerAdapter<Req, Resp>::close(ctx);
}
private:
Pipeline* pipeline_{nullptr};
folly::Optional<Promise<Resp>> p_;
};
}} // namespace
folly/wangle/service/ServerDispatcher.h deleted 100644 → 0
View file @ a716b86b
/*
* Copyright 2015 Facebook, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#pragma once
#include <folly/wangle/channel/Handler.h>
#include <folly/wangle/service/Service.h>
namespace folly { namespace wangle {
/**
* Dispatch requests from pipeline one at a time synchronously.
* Concurrent requests are queued in the pipeline.
*/
template <typename Req, typename Resp = Req>
class SerialServerDispatcher : public HandlerAdapter<Req, Resp> {
public:
typedef typename HandlerAdapter<Req, Resp>::Context Context;
explicit SerialServerDispatcher(Service<Req, Resp>* service)
: service_(service) {}
void read(Context* ctx, Req in) override {
auto resp = (*service_)(std::move(in)).get();
ctx->fireWrite(std::move(resp));
}
private:
Service<Req, Resp>* service_;
};
}} // namespace
folly/wangle/service/Service.h deleted 100644 → 0
View file @ a716b86b
/*
* Copyright 2015 Facebook, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#pragma once
#include <folly/futures/Future.h>
#include <folly/Memory.h>
#include <folly/wangle/bootstrap/ServerBootstrap.h>
#include <folly/wangle/bootstrap/ClientBootstrap.h>
#include <folly/wangle/channel/Pipeline.h>
#include <folly/wangle/channel/AsyncSocketHandler.h>
namespace folly {
/**
* A Service is an asynchronous function from Request to
* Future<Response>. It is the basic unit of the RPC interface.
*/
template <typename Req, typename Resp = Req>
class Service {
public:
virtual Future<Resp> operator()(Req request) = 0;
virtual ~Service() {}
virtual Future<void> close() {
return makeFuture();
}
virtual bool isAvailable() {
return true;
}
};
/**
* A Filter acts as a decorator/transformer of a service. It may apply
* transformations to the input and output of that service:
*
* class MyService
*
* ReqA -> |
* | -> ReqB
* | <- RespB
* RespA <- |
*
* For example, you may have a service that takes Strings and parses
* them as Ints. If you want to expose this as a Network Service via
* Thrift, it is nice to isolate the protocol handling from the
* business rules. Hence you might have a Filter that converts back
* and forth between Thrift structs:
*
* [ThriftIn -> (String -> Int) -> ThriftOut]
*/
template <typename ReqA, typename RespA,
typename ReqB = ReqA, typename RespB = RespA>
class ServiceFilter : public Service<ReqA, RespA> {
public:
explicit ServiceFilter(std::shared_ptr<Service<ReqB, RespB>> service)
: service_(service) {}
virtual ~ServiceFilter() {}
virtual Future<void> close() override {
return service_->close();
}
virtual bool isAvailable() override {
return service_->isAvailable();
}
protected:
std::shared_ptr<Service<ReqB, RespB>> service_;
};
/**
* A factory that creates services, given a client. This lets you
* make RPC calls on the Service interface over a client's pipeline.
*
* Clients can be reused after you are done using the service.
*/
template <typename Pipeline, typename Req, typename Resp>
class ServiceFactory {
public:
virtual Future<std::shared_ptr<Service<Req, Resp>>> operator()(
std::shared_ptr<ClientBootstrap<Pipeline>> client) = 0;
virtual ~ServiceFactory() = default;
};
template <typename Pipeline, typename Req, typename Resp>
class ConstFactory : public ServiceFactory<Pipeline, Req, Resp> {
public:
explicit ConstFactory(std::shared_ptr<Service<Req, Resp>> service)
: service_(service) {}
virtual Future<std::shared_ptr<Service<Req, Resp>>> operator()(
std::shared_ptr<ClientBootstrap<Pipeline>> client) {
return service_;
}
private:
std::shared_ptr<Service<Req, Resp>> service_;
};
template <typename Pipeline, typename ReqA, typename RespA,
typename ReqB = ReqA, typename RespB = RespA>
class ServiceFactoryFilter : public ServiceFactory<Pipeline, ReqA, RespA> {
public:
explicit ServiceFactoryFilter(
std::shared_ptr<ServiceFactory<Pipeline, ReqB, RespB>> serviceFactory)
: serviceFactory_(std::move(serviceFactory)) {}
virtual ~ServiceFactoryFilter() = default;
protected:
std::shared_ptr<ServiceFactory<Pipeline, ReqB, RespB>> serviceFactory_;
};
template <typename Pipeline, typename Req, typename Resp = Req>
class FactoryToService : public Service<Req, Resp> {
public:
explicit FactoryToService(
std::shared_ptr<ServiceFactory<Pipeline, Req, Resp>> factory)
: factory_(factory) {}
virtual ~FactoryToService() {}
virtual Future<Resp> operator()(Req request) override {
DCHECK(factory_);
return ((*factory_)(nullptr)).then(
[=](std::shared_ptr<Service<Req, Resp>> service)
{
return (*service)(std::move(request)).ensure(
[this]() {
this->close();
});
});
}
private:
std::shared_ptr<ServiceFactory<Pipeline, Req, Resp>> factory_;
};
} // namespace
folly/wangle/service/ServiceTest.cpp deleted 100644 → 0
View file @ a716b86b
/*
* Copyright 2015 Facebook, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <gtest/gtest.h>
#include <folly/wangle/codec/StringCodec.h>
#include <folly/wangle/codec/ByteToMessageCodec.h>
#include <folly/wangle/service/ClientDispatcher.h>
#include <folly/wangle/service/ServerDispatcher.h>
#include <folly/wangle/service/Service.h>
namespace folly {
using namespace wangle;
typedef Pipeline<IOBufQueue&, std::string> ServicePipeline;
class SimpleDecode : public ByteToMessageCodec {
public:
virtual std::unique_ptr<IOBuf> decode(
Context* ctx, IOBufQueue& buf, size_t&) {
return buf.move();
}
};
class EchoService : public Service<std::string, std::string> {
public:
virtual Future<std::string> operator()(std::string req) override {
return req;
}
};
class EchoIntService : public Service<std::string, int> {
public:
virtual Future<int> operator()(std::string req) override {
return folly::to<int>(req);
}
};
template <typename Req, typename Resp>
class ServerPipelineFactory
: public PipelineFactory<ServicePipeline> {
public:
std::unique_ptr<ServicePipeline, folly::DelayedDestruction::Destructor>
newPipeline(std::shared_ptr<AsyncSocket> socket) override {
std::unique_ptr<ServicePipeline, folly::DelayedDestruction::Destructor> pipeline(
new ServicePipeline());
pipeline->addBack(AsyncSocketHandler(socket));
pipeline->addBack(SimpleDecode());
pipeline->addBack(StringCodec());
pipeline->addBack(SerialServerDispatcher<Req, Resp>(&service_));
pipeline->finalize();
return pipeline;
}
private:
EchoService service_;
};
template <typename Req, typename Resp>
class ClientPipelineFactory : public PipelineFactory<ServicePipeline> {
public:
std::unique_ptr<ServicePipeline, folly::DelayedDestruction::Destructor>
newPipeline(std::shared_ptr<AsyncSocket> socket) override {
std::unique_ptr<ServicePipeline, folly::DelayedDestruction::Destructor> pipeline(
new ServicePipeline());
pipeline->addBack(AsyncSocketHandler(socket));
pipeline->addBack(SimpleDecode());
pipeline->addBack(StringCodec());
pipeline->finalize();
return pipeline;
}
};
template <typename Pipeline, typename Req, typename Resp>
class ClientServiceFactory : public ServiceFactory<Pipeline, Req, Resp> {
public:
class ClientService : public Service<Req, Resp> {
public:
explicit ClientService(Pipeline* pipeline) {
dispatcher_.setPipeline(pipeline);
}
Future<Resp> operator()(Req request) override {
return dispatcher_(std::move(request));
}
private:
SerialClientDispatcher<Pipeline, Req, Resp> dispatcher_;
};
Future<std::shared_ptr<Service<Req, Resp>>> operator() (
std::shared_ptr<ClientBootstrap<Pipeline>> client) override {
return Future<std::shared_ptr<Service<Req, Resp>>>(
std::make_shared<ClientService>(client->getPipeline()));
}
};
TEST(Wangle, ClientServerTest) {
int port = 1234;
// server
ServerBootstrap<ServicePipeline> server;
server.childPipeline(
std::make_shared<ServerPipelineFactory<std::string, std::string>>());
server.bind(port);
// 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("127.0.0.1", port);
client->connect(addr);
auto service = serviceFactory(client).value();
auto rep = (*service)("test");
rep.then([&](std::string value) {
EXPECT_EQ("test", value);
EventBaseManager::get()->getEventBase()->terminateLoopSoon();
});
EventBaseManager::get()->getEventBase()->loopForever();
server.stop();
client.reset();
}
class AppendFilter : public ServiceFilter<std::string, std::string> {
public:
explicit AppendFilter(
std::shared_ptr<Service<std::string, std::string>> service) :
ServiceFilter<std::string, std::string>(service) {}
virtual Future<std::string> operator()(std::string req) {
return (*service_)(req + "\n");
}
};
class IntToStringFilter
: public ServiceFilter<int, int, std::string, std::string> {
public:
explicit IntToStringFilter(
std::shared_ptr<Service<std::string, std::string>> service) :
ServiceFilter<int, int, std::string, std::string>(service) {}
virtual Future<int> operator()(int req) {
return (*service_)(folly::to<std::string>(req)).then([](std::string resp) {
return folly::to<int>(resp);
});
}
};
TEST(Wangle, FilterTest) {
auto service = std::make_shared<EchoService>();
auto filter = std::make_shared<AppendFilter>(service);
auto result = (*filter)("test");
EXPECT_EQ(result.value(), "test\n");
}
TEST(Wangle, ComplexFilterTest) {
auto service = std::make_shared<EchoService>();
auto filter = std::make_shared<IntToStringFilter>(service);
auto result = (*filter)(1);
EXPECT_EQ(result.value(), 1);
}
class ChangeTypeFilter
: public ServiceFilter<int, std::string, std::string, int> {
public:
explicit ChangeTypeFilter(
std::shared_ptr<Service<std::string, int>> service) :
ServiceFilter<int, std::string, std::string, int>(service) {}
virtual Future<std::string> operator()(int req) {
return (*service_)(folly::to<std::string>(req)).then([](int resp) {
return folly::to<std::string>(resp);
});
}
};
TEST(Wangle, SuperComplexFilterTest) {
auto service = std::make_shared<EchoIntService>();
auto filter = std::make_shared<ChangeTypeFilter>(service);
auto result = (*filter)(1);
EXPECT_EQ(result.value(), "1");
}
template <typename Pipeline, typename Req, typename Resp>
class ConnectionCountFilter : public ServiceFactoryFilter<Pipeline, Req, Resp> {
public:
explicit ConnectionCountFilter(
std::shared_ptr<ServiceFactory<Pipeline, Req, Resp>> factory)
: ServiceFactoryFilter<Pipeline, Req, Resp>(factory) {}
virtual Future<std::shared_ptr<Service<Req, Resp>>> operator()(
std::shared_ptr<ClientBootstrap<Pipeline>> client) {
connectionCount++;
return (*this->serviceFactory_)(client);
}
int connectionCount{0};
};
TEST(Wangle, ServiceFactoryFilter) {
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>>());
// It doesn't matter if connect succeds or not, but it needs to be called
// to create a pipeline
client->connect(folly::SocketAddress("::1", 8090));
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);
}
TEST(Wangle, FactoryToService) {
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());
}
int main(int argc, char** argv) {
testing::InitGoogleTest(&argc, argv);
google::InitGoogleLogging(argv[0]);
gflags::ParseCommandLineFlags(&argc, &argv, true);
return RUN_ALL_TESTS();
}
} // namespace
folly/wangle/ssl/ClientHelloExtStats.h deleted 100644 → 0
View file @ a716b86b
/*
* Copyright (c) 2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
*/
#pragma once
namespace folly {
class ClientHelloExtStats {
public:
virtual ~ClientHelloExtStats() noexcept {}
// client hello
virtual void recordAbsentHostname() noexcept = 0;
virtual void recordMatch() noexcept = 0;
virtual void recordNotMatch() noexcept = 0;
};
}
folly/wangle/ssl/DHParam.h deleted 100644 → 0
View file @ a716b86b
/*
* Copyright (c) 2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
*/
#pragma once
#include <openssl/dh.h>
// The following was auto-generated by
// openssl dhparam -C 2048
DH *get_dh2048()
{
static unsigned char dh2048_p[]={
0xF8,0x87,0xA5,0x15,0x98,0x35,0x20,0x1E,0xF5,0x81,0xE5,0x95,
0x1B,0xE4,0x54,0xEA,0x53,0xF5,0xE7,0x26,0x30,0x03,0x06,0x79,
0x3C,0xC1,0x0B,0xAD,0x3B,0x59,0x3C,0x61,0x13,0x03,0x7B,0x02,
0x70,0xDE,0xC1,0x20,0x11,0x9E,0x94,0x13,0x50,0xF7,0x62,0xFC,
0x99,0x0D,0xC1,0x12,0x6E,0x03,0x95,0xA3,0x57,0xC7,0x3C,0xB8,
0x6B,0x40,0x56,0x65,0x70,0xFB,0x7A,0xE9,0x02,0xEC,0xD2,0xB6,
0x54,0xD7,0x34,0xAD,0x3D,0x9E,0x11,0x61,0x53,0xBE,0xEA,0xB8,
0x17,0x48,0xA8,0xDC,0x70,0xAE,0x65,0x99,0x3F,0x82,0x4C,0xFF,
0x6A,0xC9,0xFA,0xB1,0xFA,0xE4,0x4F,0x5D,0xA4,0x05,0xC2,0x8E,
0x55,0xC0,0xB1,0x1D,0xCC,0x17,0xF3,0xFA,0x65,0xD8,0x6B,0x09,
0x13,0x01,0x2A,0x39,0xF1,0x86,0x73,0xE3,0x7A,0xC8,0xDB,0x7D,
0xDA,0x1C,0xA1,0x2D,0xBA,0x2C,0x00,0x6B,0x2C,0x55,0x28,0x2B,
0xD5,0xF5,0x3C,0x9F,0x50,0xA7,0xB7,0x28,0x9F,0x22,0xD5,0x3A,
0xC4,0x53,0x01,0xC9,0xF3,0x69,0xB1,0x8D,0x01,0x36,0xF8,0xA8,
0x89,0xCA,0x2E,0x72,0xBC,0x36,0x3A,0x42,0xC1,0x06,0xD6,0x0E,
0xCB,0x4D,0x5C,0x1F,0xE4,0xA1,0x17,0xBF,0x55,0x64,0x1B,0xB4,
0x52,0xEC,0x15,0xED,0x32,0xB1,0x81,0x07,0xC9,0x71,0x25,0xF9,
0x4D,0x48,0x3D,0x18,0xF4,0x12,0x09,0x32,0xC4,0x0B,0x7A,0x4E,
0x83,0xC3,0x10,0x90,0x51,0x2E,0xBE,0x87,0xF9,0xDE,0xB4,0xE6,
0x3C,0x29,0xB5,0x32,0x01,0x9D,0x95,0x04,0xBD,0x42,0x89,0xFD,
0x21,0xEB,0xE9,0x88,0x5A,0x27,0xBB,0x31,0xC4,0x26,0x99,0xAB,
0x8C,0xA1,0x76,0xDB,
};
static unsigned char dh2048_g[]={
0x02,
};
DH *dh;
if ((dh=DH_new()) == nullptr) return(nullptr);
dh->p=BN_bin2bn(dh2048_p,(int)sizeof(dh2048_p),nullptr);
dh->g=BN_bin2bn(dh2048_g,(int)sizeof(dh2048_g),nullptr);
if ((dh->p == nullptr) || (dh->g == nullptr))
{ DH_free(dh); return(nullptr); }
return(dh);
}
folly/wangle/ssl/PasswordInFile.cpp deleted 100644 → 0
View file @ a716b86b
/*
* Copyright (c) 2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
*/
#include <folly/wangle/ssl/PasswordInFile.h>
#include <folly/FileUtil.h>
using namespace std;
namespace folly {
PasswordInFile::PasswordInFile(const string& file)
: fileName_(file) {
folly::readFile(file.c_str(), password_);
auto p = password_.find('\0');
if (p != std::string::npos) {
password_.erase(p);
}
}
PasswordInFile::~PasswordInFile() {
OPENSSL_cleanse((char *)password_.data(), password_.length());
}
}
folly/wangle/ssl/PasswordInFile.h deleted 100644 → 0
View file @ a716b86b
/*
* Copyright (c) 2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
*/
#pragma once
#include <folly/io/async/SSLContext.h> // PasswordCollector
namespace folly {
class PasswordInFile: public folly::PasswordCollector {
public:
explicit PasswordInFile(const std::string& file);
~PasswordInFile();
void getPassword(std::string& password, int size) override {
password = password_;
}
const char* getPasswordStr() const {
return password_.c_str();
}
std::string describe() const override {
return fileName_;
}
protected:
std::string fileName_;
std::string password_;
};
}
folly/wangle/ssl/SSLCacheOptions.h deleted 100644 → 0
View file @ a716b86b
/*
* Copyright (c) 2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
*/
#pragma once
#include <chrono>
#include <cstdint>
namespace folly {
struct SSLCacheOptions {
std::chrono::seconds sslCacheTimeout;
uint64_t maxSSLCacheSize;
uint64_t sslCacheFlushSize;
};
}
folly/wangle/ssl/SSLCacheProvider.h deleted 100644 → 0
View file @ a716b86b
/*
* Copyright (c) 2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
*/
#pragma once
#include <folly/io/async/AsyncSSLSocket.h>
namespace folly {
class SSLSessionCacheManager;
/**
* Interface to be implemented by providers of external session caches
*/
class SSLCacheProvider {
public:
/**
* Context saved during an external cache request that is used to
* resume the waiting client.
*/
typedef struct {
std::string sessionId;
SSL_SESSION* session;
SSLSessionCacheManager* manager;
AsyncSSLSocket* sslSocket;
std::unique_ptr<
folly::DelayedDestruction::DestructorGuard> guard;
} CacheContext;
virtual ~SSLCacheProvider() {}
/**
* Store a session in the external cache.
* @param sessionId Identifier that can be used later to fetch the
* session with getAsync()
* @param value Serialized session to store
* @param expiration Relative expiration time: seconds from now
* @return true if the storing of the session is initiated successfully
* (though not necessarily completed; the completion may
* happen either before or after this method returns), or
* false if the storing cannot be initiated due to an error.
*/
virtual bool setAsync(const std::string& sessionId,
const std::string& value,
std::chrono::seconds expiration) = 0;
/**
* Retrieve a session from the external cache. When done, call
* the cache manager's onGetSuccess() or onGetFailure() callback.
* @param sessionId Session ID to fetch
* @param context Data to pass back to the SSLSessionCacheManager
* in the completion callback
* @return true if the lookup of the session is initiated successfully
* (though not necessarily completed; the completion may
* happen either before or after this method returns), or
* false if the lookup cannot be initiated due to an error.
*/
virtual bool getAsync(const std::string& sessionId,
CacheContext* context) = 0;
};
}
folly/wangle/ssl/SSLContextConfig.h deleted 100644 → 0
View file @ a716b86b
/*
* Copyright (c) 2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
*/
#pragma once
#include <string>
#include <folly/io/async/SSLContext.h>
#include <vector>
/**
* 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
*/
namespace folly {
struct SSLContextConfig {
SSLContextConfig() {}
~SSLContextConfig() {}
struct CertificateInfo {
std::string certPath;
std::string keyPath;
std::string passwordPath;
};
/**
* Helpers to set/add a certificate
*/
void setCertificate(const std::string& certPath,
const std::string& keyPath,
const std::string& passwordPath) {
certificates.clear();
addCertificate(certPath, keyPath, passwordPath);
}
void addCertificate(const std::string& certPath,
const std::string& keyPath,
const std::string& passwordPath) {
certificates.emplace_back(CertificateInfo{certPath, keyPath, passwordPath});
}
/**
* Set the optional list of protocols to advertise via TLS
* Next Protocol Negotiation. An empty list means NPN is not enabled.
*/
void setNextProtocols(const std::list<std::string>& inNextProtocols) {
nextProtocols.clear();
nextProtocols.push_back({1, inNextProtocols});
}
typedef std::function<bool(char const* server_name)> SNINoMatchFn;
std::vector<CertificateInfo> certificates;
folly::SSLContext::SSLVersion sslVersion{
folly::SSLContext::TLSv1};
bool sessionCacheEnabled{true};
bool sessionTicketEnabled{true};
bool clientHelloParsingEnabled{false};
std::string sslCiphers{
"ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES256-GCM-SHA384:"
"ECDHE-ECDSA-AES128-SHA:ECDHE-ECDSA-AES256-SHA:ECDHE-RSA-AES128-GCM-SHA256:"
"ECDHE-RSA-AES256-GCM-SHA384:ECDHE-RSA-AES128-SHA:ECDHE-RSA-AES256-SHA:"
"AES128-GCM-SHA256:AES256-GCM-SHA384:AES128-SHA:AES256-SHA:"
"ECDHE-ECDSA-RC4-SHA:ECDHE-RSA-RC4-SHA:RC4-SHA:RC4-MD5:"
"ECDHE-RSA-DES-CBC3-SHA:DES-CBC3-SHA"};
std::string eccCurveName;
// Ciphers to negotiate if TLS version >= 1.1
std::string tls11Ciphers{""};
// Weighted lists of NPN strings to advertise
std::list<folly::SSLContext::NextProtocolsItem>
nextProtocols;
bool isLocalPrivateKey{true};
// Should this SSLContextConfig be the default for SNI purposes
bool isDefault{false};
// Callback function to invoke when there are no matching certificates
// (will only be invoked once)
SNINoMatchFn sniNoMatchFn;
// File containing trusted CA's to validate client certificates
std::string clientCAFile;
};
}
folly/wangle/ssl/SSLContextManager.cpp deleted 100644 → 0
View file @ a716b86b
/*
* Copyright (c) 2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
*/
#include <folly/wangle/ssl/SSLContextManager.h>
#include <folly/wangle/ssl/ClientHelloExtStats.h>
#include <folly/wangle/ssl/DHParam.h>
#include <folly/wangle/ssl/PasswordInFile.h>
#include <folly/wangle/ssl/SSLCacheOptions.h>
#include <folly/wangle/ssl/SSLSessionCacheManager.h>
#include <folly/wangle/ssl/SSLUtil.h>
#include <folly/wangle/ssl/TLSTicketKeyManager.h>
#include <folly/wangle/ssl/TLSTicketKeySeeds.h>
#include <folly/Conv.h>
#include <folly/ScopeGuard.h>
#include <folly/String.h>
#include <functional>
#include <openssl/asn1.h>
#include <openssl/ssl.h>
#include <string>
#include <folly/io/async/EventBase.h>
#define OPENSSL_MISSING_FEATURE(name) \
do { \
throw std::runtime_error("missing " #name " support in openssl"); \
} while(0)
using std::string;
using std::shared_ptr;
/**
* 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.
*/
namespace folly {
namespace {
X509* getX509(SSL_CTX* ctx) {
SSL* ssl = SSL_new(ctx);
SSL_set_connect_state(ssl);
X509* x509 = SSL_get_certificate(ssl);
CRYPTO_add(&x509->references, 1, CRYPTO_LOCK_X509);
SSL_free(ssl);
return x509;
}
void set_key_from_curve(SSL_CTX* ctx, const std::string& curveName) {
#if OPENSSL_VERSION_NUMBER >= 0x0090800fL
#ifndef OPENSSL_NO_ECDH
EC_KEY* ecdh = nullptr;
int nid;
/*
* Elliptic-Curve Diffie-Hellman parameters are either "named curves"
* from RFC 4492 section 5.1.1, or explicitly described curves over
* binary fields. OpenSSL only supports the "named curves", which provide
* maximum interoperability.
*/
nid = OBJ_sn2nid(curveName.c_str());
if (nid == 0) {
LOG(FATAL) << "Unknown curve name:" << curveName.c_str();
return;
}
ecdh = EC_KEY_new_by_curve_name(nid);
if (ecdh == nullptr) {
LOG(FATAL) << "Unable to create curve:" << curveName.c_str();
return;
}
SSL_CTX_set_tmp_ecdh(ctx, ecdh);
EC_KEY_free(ecdh);
#endif
#endif
}
// Helper to create TLSTicketKeyManger and aware of the needed openssl
// version/feature.
std::unique_ptr<TLSTicketKeyManager> createTicketManagerHelper(
std::shared_ptr<folly::SSLContext> ctx,
const TLSTicketKeySeeds* ticketSeeds,
const SSLContextConfig& ctxConfig,
SSLStats* stats) {
std::unique_ptr<TLSTicketKeyManager> ticketManager;
#ifdef SSL_CTRL_SET_TLSEXT_TICKET_KEY_CB
if (ticketSeeds && ctxConfig.sessionTicketEnabled) {
ticketManager = folly::make_unique<TLSTicketKeyManager>(ctx.get(), stats);
ticketManager->setTLSTicketKeySeeds(
ticketSeeds->oldSeeds,
ticketSeeds->currentSeeds,
ticketSeeds->newSeeds);
} else {
ctx->setOptions(SSL_OP_NO_TICKET);
}
#else
if (ticketSeeds && ctxConfig.sessionTicketEnabled) {
OPENSSL_MISSING_FEATURE(TLSTicket);
}
#endif
return ticketManager;
}
std::string flattenList(const std::list<std::string>& list) {
std::string s;
bool first = true;
for (auto& item : list) {
if (first) {
first = false;
} else {
s.append(", ");
}
s.append(item);
}
return s;
}
}
SSLContextManager::~SSLContextManager() {}
SSLContextManager::SSLContextManager(
EventBase* eventBase,
const std::string& vipName,
bool strict,
SSLStats* stats) :
stats_(stats),
eventBase_(eventBase),
strict_(strict) {
}
void SSLContextManager::addSSLContextConfig(
const SSLContextConfig& ctxConfig,
const SSLCacheOptions& cacheOptions,
const TLSTicketKeySeeds* ticketSeeds,
const folly::SocketAddress& vipAddress,
const std::shared_ptr<SSLCacheProvider>& externalCache) {
unsigned numCerts = 0;
std::string commonName;
std::string lastCertPath;
std::unique_ptr<std::list<std::string>> subjectAltName;
auto sslCtx = std::make_shared<SSLContext>(ctxConfig.sslVersion);
for (const auto& cert : ctxConfig.certificates) {
try {
sslCtx->loadCertificate(cert.certPath.c_str());
} catch (const std::exception& ex) {
// The exception isn't very useful without the certificate path name,
// so throw a new exception that includes the path to the certificate.
string msg = folly::to<string>("error loading SSL certificate ",
cert.certPath, ": ",
folly::exceptionStr(ex));
LOG(ERROR) << msg;
throw std::runtime_error(msg);
}
// Verify that the Common Name and (if present) Subject Alternative Names
// are the same for all the certs specified for the SSL context.
numCerts++;
X509* x509 = getX509(sslCtx->getSSLCtx());
auto guard = folly::makeGuard([x509] { X509_free(x509); });
auto cn = SSLUtil::getCommonName(x509);
if (!cn) {
throw std::runtime_error(folly::to<string>("Cannot get CN for X509 ",
cert.certPath));
}
auto altName = SSLUtil::getSubjectAltName(x509);
VLOG(2) << "cert " << cert.certPath << " CN: " << *cn;
if (altName) {
altName->sort();
VLOG(2) << "cert " << cert.certPath << " SAN: " << flattenList(*altName);
} else {
VLOG(2) << "cert " << cert.certPath << " SAN: " << "{none}";
}
if (numCerts == 1) {
commonName = *cn;
subjectAltName = std::move(altName);
} else {
if (commonName != *cn) {
throw std::runtime_error(folly::to<string>("X509 ", cert.certPath,
" does not have same CN as ",
lastCertPath));
}
if (altName == nullptr) {
if (subjectAltName != nullptr) {
throw std::runtime_error(folly::to<string>("X509 ", cert.certPath,
" does not have same SAN as ",
lastCertPath));
}
} else {
if ((subjectAltName == nullptr) || (*altName != *subjectAltName)) {
throw std::runtime_error(folly::to<string>("X509 ", cert.certPath,
" does not have same SAN as ",
lastCertPath));
}
}
}
lastCertPath = cert.certPath;
// TODO t4438250 - Add ECDSA support to the crypto_ssl offload server
// so we can avoid storing the ECDSA private key in the
// address space of the Internet-facing process. For
// now, if cert name includes "-EC" to denote elliptic
// curve, we load its private key even if the server as
// a whole has been configured for async crypto.
if (ctxConfig.isLocalPrivateKey ||
(cert.certPath.find("-EC") != std::string::npos)) {
// The private key lives in the same process
// This needs to be called before loadPrivateKey().
if (!cert.passwordPath.empty()) {
auto sslPassword = std::make_shared<PasswordInFile>(cert.passwordPath);
sslCtx->passwordCollector(sslPassword);
}
try {
sslCtx->loadPrivateKey(cert.keyPath.c_str());
} catch (const std::exception& ex) {
// Throw an error that includes the key path, so the user can tell
// which key had a problem.
string msg = folly::to<string>("error loading private SSL key ",
cert.keyPath, ": ",
folly::exceptionStr(ex));
LOG(ERROR) << msg;
throw std::runtime_error(msg);
}
}
}
if (!ctxConfig.isLocalPrivateKey) {
enableAsyncCrypto(sslCtx);
}
// Let the server pick the highest performing cipher from among the client's
// choices.
//
// Let's use a unique private key for all DH key exchanges.
//
// Because some old implementations choke on empty fragments, most SSL
// applications disable them (it's part of SSL_OP_ALL). This
// will improve performance and decrease write buffer fragmentation.
sslCtx->setOptions(SSL_OP_CIPHER_SERVER_PREFERENCE |
SSL_OP_SINGLE_DH_USE |
SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS);
// Configure SSL ciphers list
if (!ctxConfig.tls11Ciphers.empty()) {
// FIXME: create a dummy SSL_CTX for cipher testing purpose? It can
// remove the ordering dependency
// Test to see if the specified TLS1.1 ciphers are valid. Note that
// these will be overwritten by the ciphers() call below.
sslCtx->setCiphersOrThrow(ctxConfig.tls11Ciphers);
}
// Important that we do this *after* checking the TLS1.1 ciphers above,
// since we test their validity by actually setting them.
sslCtx->ciphers(ctxConfig.sslCiphers);
// Use a fix DH param
DH* dh = get_dh2048();
SSL_CTX_set_tmp_dh(sslCtx->getSSLCtx(), dh);
DH_free(dh);
const string& curve = ctxConfig.eccCurveName;
if (!curve.empty()) {
set_key_from_curve(sslCtx->getSSLCtx(), curve);
}
if (!ctxConfig.clientCAFile.empty()) {
try {
sslCtx->setVerificationOption(SSLContext::VERIFY_REQ_CLIENT_CERT);
sslCtx->loadTrustedCertificates(ctxConfig.clientCAFile.c_str());
sslCtx->loadClientCAList(ctxConfig.clientCAFile.c_str());
} catch (const std::exception& ex) {
string msg = folly::to<string>("error loading client CA",
ctxConfig.clientCAFile, ": ",
folly::exceptionStr(ex));
LOG(ERROR) << msg;
throw std::runtime_error(msg);
}
}
// - start - SSL session cache config
// the internal cache never does what we want (per-thread-per-vip).
// Disable it. SSLSessionCacheManager will set it appropriately.
SSL_CTX_set_session_cache_mode(sslCtx->getSSLCtx(), SSL_SESS_CACHE_OFF);
SSL_CTX_set_timeout(sslCtx->getSSLCtx(),
cacheOptions.sslCacheTimeout.count());
std::unique_ptr<SSLSessionCacheManager> sessionCacheManager;
if (ctxConfig.sessionCacheEnabled &&
cacheOptions.maxSSLCacheSize > 0 &&
cacheOptions.sslCacheFlushSize > 0) {
sessionCacheManager =
folly::make_unique<SSLSessionCacheManager>(
cacheOptions.maxSSLCacheSize,
cacheOptions.sslCacheFlushSize,
sslCtx.get(),
vipAddress,
commonName,
eventBase_,
stats_,
externalCache);
}
// - end - SSL session cache config
std::unique_ptr<TLSTicketKeyManager> ticketManager =
createTicketManagerHelper(sslCtx, ticketSeeds, ctxConfig, stats_);
// finalize sslCtx setup by the individual features supported by openssl
ctxSetupByOpensslFeature(sslCtx, ctxConfig);
try {
insert(sslCtx,
std::move(sessionCacheManager),
std::move(ticketManager),
ctxConfig.isDefault);
} catch (const std::exception& ex) {
string msg = folly::to<string>("Error adding certificate : ",
folly::exceptionStr(ex));
LOG(ERROR) << msg;
throw std::runtime_error(msg);
}
}
#ifdef PROXYGEN_HAVE_SERVERNAMECALLBACK
SSLContext::ServerNameCallbackResult
SSLContextManager::serverNameCallback(SSL* ssl) {
shared_ptr<SSLContext> ctx;
const char* sn = SSL_get_servername(ssl, TLSEXT_NAMETYPE_host_name);
if (!sn) {
VLOG(6) << "Server Name (tlsext_hostname) is missing";
if (clientHelloTLSExtStats_) {
clientHelloTLSExtStats_->recordAbsentHostname();
}
return SSLContext::SERVER_NAME_NOT_FOUND;
}
size_t snLen = strlen(sn);
VLOG(6) << "Server Name (SNI TLS extension): '" << sn << "' ";
// FIXME: This code breaks the abstraction. Suggestion?
AsyncSSLSocket* sslSocket = AsyncSSLSocket::getFromSSL(ssl);
CHECK(sslSocket);
DNString dnstr(sn, snLen);
uint32_t count = 0;
do {
// Try exact match first
ctx = getSSLCtx(dnstr);
if (ctx) {
sslSocket->switchServerSSLContext(ctx);
if (clientHelloTLSExtStats_) {
clientHelloTLSExtStats_->recordMatch();
}
return SSLContext::SERVER_NAME_FOUND;
}
ctx = getSSLCtxBySuffix(dnstr);
if (ctx) {
sslSocket->switchServerSSLContext(ctx);
if (clientHelloTLSExtStats_) {
clientHelloTLSExtStats_->recordMatch();
}
return SSLContext::SERVER_NAME_FOUND;
}
// Give the noMatchFn one chance to add the correct cert
}
while (count++ == 0 && noMatchFn_ && noMatchFn_(sn));
VLOG(6) << folly::stringPrintf("Cannot find a SSL_CTX for \"%s\"", sn);
if (clientHelloTLSExtStats_) {
clientHelloTLSExtStats_->recordNotMatch();
}
return SSLContext::SERVER_NAME_NOT_FOUND;
}
#endif
// Consolidate all SSL_CTX setup which depends on openssl version/feature
void
SSLContextManager::ctxSetupByOpensslFeature(
shared_ptr<folly::SSLContext> sslCtx,
const SSLContextConfig& ctxConfig) {
// Disable compression - profiling shows this to be very expensive in
// terms of CPU and memory consumption.
//
#ifdef SSL_OP_NO_COMPRESSION
sslCtx->setOptions(SSL_OP_NO_COMPRESSION);
#endif
// Enable early release of SSL buffers to reduce the memory footprint
#ifdef SSL_MODE_RELEASE_BUFFERS
sslCtx->getSSLCtx()->mode |= SSL_MODE_RELEASE_BUFFERS;
#endif
#ifdef SSL_MODE_EARLY_RELEASE_BBIO
sslCtx->getSSLCtx()->mode |= SSL_MODE_EARLY_RELEASE_BBIO;
#endif
// This number should (probably) correspond to HTTPSession::kMaxReadSize
// For now, this number must also be large enough to accommodate our
// largest certificate, because some older clients (IE6/7) require the
// cert to be in a single fragment.
#ifdef SSL_CTRL_SET_MAX_SEND_FRAGMENT
SSL_CTX_set_max_send_fragment(sslCtx->getSSLCtx(), 8000);
#endif
// Specify cipher(s) to be used for TLS1.1 client
if (!ctxConfig.tls11Ciphers.empty()) {
#ifdef PROXYGEN_HAVE_SERVERNAMECALLBACK
// Specified TLS1.1 ciphers are valid
sslCtx->addClientHelloCallback(
std::bind(
&SSLContext::switchCiphersIfTLS11,
sslCtx.get(),
std::placeholders::_1,
ctxConfig.tls11Ciphers
)
);
#else
OPENSSL_MISSING_FEATURE(SNI);
#endif
}
// NPN (Next Protocol Negotiation)
if (!ctxConfig.nextProtocols.empty()) {
#ifdef OPENSSL_NPN_NEGOTIATED
sslCtx->setRandomizedAdvertisedNextProtocols(ctxConfig.nextProtocols);
#else
OPENSSL_MISSING_FEATURE(NPN);
#endif
}
// SNI
#ifdef PROXYGEN_HAVE_SERVERNAMECALLBACK
noMatchFn_ = ctxConfig.sniNoMatchFn;
if (ctxConfig.isDefault) {
if (defaultCtx_) {
throw std::runtime_error(">1 X509 is set as default");
}
defaultCtx_ = sslCtx;
defaultCtx_->setServerNameCallback(
std::bind(&SSLContextManager::serverNameCallback, this,
std::placeholders::_1));
}
#else
if (ctxs_.size() > 1) {
OPENSSL_MISSING_FEATURE(SNI);
}
#endif
}
void
SSLContextManager::insert(shared_ptr<SSLContext> sslCtx,
std::unique_ptr<SSLSessionCacheManager> smanager,
std::unique_ptr<TLSTicketKeyManager> tmanager,
bool defaultFallback) {
X509* x509 = getX509(sslCtx->getSSLCtx());
auto guard = folly::makeGuard([x509] { X509_free(x509); });
auto cn = SSLUtil::getCommonName(x509);
if (!cn) {
throw std::runtime_error("Cannot get CN");
}
/**
* Some notes from RFC 2818. Only for future quick references in case of bugs
*
* RFC 2818 section 3.1:
* "......
* If a subjectAltName extension of type dNSName is present, that MUST
* be used as the identity. Otherwise, the (most specific) Common Name
* field in the Subject field of the certificate MUST be used. Although
* the use of the Common Name is existing practice, it is deprecated and
* Certification Authorities are encouraged to use the dNSName instead.
* ......
* In some cases, the URI is specified as an IP address rather than a
* hostname. In this case, the iPAddress subjectAltName must be present
* in the certificate and must exactly match the IP in the URI.
* ......"
*/
// Not sure if we ever get this kind of X509...
// If we do, assume '*' is always in the CN and ignore all subject alternative
// names.
if (cn->length() == 1 && (*cn)[0] == '*') {
if (!defaultFallback) {
throw std::runtime_error("STAR X509 is not the default");
}
ctxs_.emplace_back(sslCtx);
sessionCacheManagers_.emplace_back(std::move(smanager));
ticketManagers_.emplace_back(std::move(tmanager));
return;
}
// Insert by CN
insertSSLCtxByDomainName(cn->c_str(), cn->length(), sslCtx);
// Insert by subject alternative name(s)
auto altNames = SSLUtil::getSubjectAltName(x509);
if (altNames) {
for (auto& name : *altNames) {
insertSSLCtxByDomainName(name.c_str(), name.length(), sslCtx);
}
}
ctxs_.emplace_back(sslCtx);
sessionCacheManagers_.emplace_back(std::move(smanager));
ticketManagers_.emplace_back(std::move(tmanager));
}
void
SSLContextManager::insertSSLCtxByDomainName(const char* dn, size_t len,
shared_ptr<SSLContext> sslCtx) {
try {
insertSSLCtxByDomainNameImpl(dn, len, sslCtx);
} catch (const std::runtime_error& ex) {
if (strict_) {
throw ex;
} else {
LOG(ERROR) << ex.what() << " DN=" << dn;
}
}
}
void
SSLContextManager::insertSSLCtxByDomainNameImpl(const char* dn, size_t len,
shared_ptr<SSLContext> sslCtx)
{
VLOG(4) <<
folly::stringPrintf("Adding CN/Subject-alternative-name \"%s\" for "
"SNI search", dn);
// Only support wildcard domains which are prefixed exactly by "*." .
// "*" appearing at other locations is not accepted.
if (len > 2 && dn[0] == '*') {
if (dn[1] == '.') {
// skip the first '*'
dn++;
len--;
} else {
throw std::runtime_error(
"Invalid wildcard CN/subject-alternative-name \"" + std::string(dn) + "\" "
"(only allow character \".\" after \"*\"");
}
}
if (len == 1 && *dn == '.') {
throw std::runtime_error("X509 has only '.' in the CN or subject alternative name "
"(after removing any preceding '*')");
}
if (strchr(dn, '*')) {
throw std::runtime_error("X509 has '*' in the the CN or subject alternative name "
"(after removing any preceding '*')");
}
DNString dnstr(dn, len);
const auto v = dnMap_.find(dnstr);
if (v == dnMap_.end()) {
dnMap_.emplace(dnstr, sslCtx);
} else if (v->second == sslCtx) {
VLOG(6)<< "Duplicate CN or subject alternative name found in the same X509."
" Ignore the later name.";
} else {
throw std::runtime_error("Duplicate CN or subject alternative name found: \"" +
std::string(dnstr.c_str()) + "\"");
}
}
shared_ptr<SSLContext>
SSLContextManager::getSSLCtxBySuffix(const DNString& dnstr) const
{
size_t dot;
if ((dot = dnstr.find_first_of(".")) != DNString::npos) {
DNString suffixDNStr(dnstr, dot);
const auto v = dnMap_.find(suffixDNStr);
if (v != dnMap_.end()) {
VLOG(6) << folly::stringPrintf("\"%s\" is a willcard match to \"%s\"",
dnstr.c_str(), suffixDNStr.c_str());
return v->second;
}
}
VLOG(6) << folly::stringPrintf("\"%s\" is not a wildcard match",
dnstr.c_str());
return shared_ptr<SSLContext>();
}
shared_ptr<SSLContext>
SSLContextManager::getSSLCtx(const DNString& dnstr) const
{
const auto v = dnMap_.find(dnstr);
if (v == dnMap_.end()) {
VLOG(6) << folly::stringPrintf("\"%s\" is not an exact match",
dnstr.c_str());
return shared_ptr<SSLContext>();
} else {
VLOG(6) << folly::stringPrintf("\"%s\" is an exact match", dnstr.c_str());
return v->second;
}
}
shared_ptr<SSLContext>
SSLContextManager::getDefaultSSLCtx() const {
return defaultCtx_;
}
void
SSLContextManager::reloadTLSTicketKeys(
const std::vector<std::string>& oldSeeds,
const std::vector<std::string>& currentSeeds,
const std::vector<std::string>& newSeeds) {
#ifdef SSL_CTRL_SET_TLSEXT_TICKET_KEY_CB
for (auto& tmgr: ticketManagers_) {
tmgr->setTLSTicketKeySeeds(oldSeeds, currentSeeds, newSeeds);
}
#endif
}
} // namespace
folly/wangle/ssl/SSLContextManager.h deleted 100644 → 0
View file @ a716b86b
/*
* Copyright (c) 2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
*/
#pragma once
#include <folly/io/async/EventBase.h>
#include <folly/io/async/SSLContext.h>
#include <glog/logging.h>
#include <list>
#include <memory>
#include <folly/wangle/ssl/SSLContextConfig.h>
#include <folly/wangle/ssl/SSLSessionCacheManager.h>
#include <folly/wangle/ssl/TLSTicketKeySeeds.h>
#include <folly/wangle/acceptor/DomainNameMisc.h>
#include <vector>
namespace folly {
class SocketAddress;
class SSLContext;
class ClientHelloExtStats;
struct SSLCacheOptions;
class SSLStats;
class TLSTicketKeyManager;
struct TLSTicketKeySeeds;
class SSLContextManager {
public:
explicit SSLContextManager(EventBase* eventBase,
const std::string& vipName, bool strict,
SSLStats* stats);
virtual ~SSLContextManager();
/**
* Add a new X509 to SSLContextManager. The details of a X509
* is passed as a SSLContextConfig object.
*
* @param ctxConfig Details of a X509, its private key, password, etc.
* @param cacheOptions Options for how to do session caching.
* @param ticketSeeds If non-null, the initial ticket key seeds to use.
* @param vipAddress Which VIP are the X509(s) used for? It is only for
* for user friendly log message
* @param externalCache Optional external provider for the session cache;
* may be null
*/
void addSSLContextConfig(
const SSLContextConfig& ctxConfig,
const SSLCacheOptions& cacheOptions,
const TLSTicketKeySeeds* ticketSeeds,
const folly::SocketAddress& vipAddress,
const std::shared_ptr<SSLCacheProvider> &externalCache);
/**
* Get the default SSL_CTX for a VIP
*/
std::shared_ptr<SSLContext>
getDefaultSSLCtx() const;
/**
* Search by the _one_ level up subdomain
*/
std::shared_ptr<SSLContext>
getSSLCtxBySuffix(const DNString& dnstr) const;
/**
* Search by the full-string domain name
*/
std::shared_ptr<SSLContext>
getSSLCtx(const DNString& dnstr) const;
/**
* Insert a SSLContext by domain name.
*/
void insertSSLCtxByDomainName(
const char* dn,
size_t len,
std::shared_ptr<SSLContext> sslCtx);
void insertSSLCtxByDomainNameImpl(
const char* dn,
size_t len,
std::shared_ptr<SSLContext> sslCtx);
void reloadTLSTicketKeys(const std::vector<std::string>& oldSeeds,
const std::vector<std::string>& currentSeeds,
const std::vector<std::string>& newSeeds);
/**
* SSLContextManager only collects SNI stats now
*/
void setClientHelloExtStats(ClientHelloExtStats* stats) {
clientHelloTLSExtStats_ = stats;
}
protected:
virtual void enableAsyncCrypto(
const std::shared_ptr<SSLContext>& sslCtx) {
LOG(FATAL) << "Unsupported in base SSLContextManager";
}
SSLStats* stats_{nullptr};
private:
SSLContextManager(const SSLContextManager&) = delete;
void ctxSetupByOpensslFeature(
std::shared_ptr<SSLContext> sslCtx,
const SSLContextConfig& ctxConfig);
/**
* Callback function from openssl to find the right X509 to
* use during SSL handshake
*/
#if OPENSSL_VERSION_NUMBER >= 0x1000105fL && \
!defined(OPENSSL_NO_TLSEXT) && \
defined(SSL_CTRL_SET_TLSEXT_SERVERNAME_CB)
# define PROXYGEN_HAVE_SERVERNAMECALLBACK
SSLContext::ServerNameCallbackResult
serverNameCallback(SSL* ssl);
#endif
/**
* The following functions help to maintain the data structure for
* domain name matching in SNI. Some notes:
*
* 1. It is a best match.
*
* 2. It allows wildcard CN and wildcard subject alternative name in a X509.
* The wildcard name must be _prefixed_ by '*.'. It errors out whenever
* it sees '*' in any other locations.
*
* 3. It uses one std::unordered_map<DomainName, SSL_CTX> object to
* do this. For wildcard name like "*.facebook.com", ".facebook.com"
* is used as the key.
*
* 4. After getting tlsext_hostname from the client hello message, it
* will do a full string search first and then try one level up to
* match any wildcard name (if any) in the X509.
* [Note, browser also only looks one level up when matching the requesting
* domain name with the wildcard name in the server X509].
*/
void insert(
std::shared_ptr<SSLContext> sslCtx,
std::unique_ptr<SSLSessionCacheManager> cmanager,
std::unique_ptr<TLSTicketKeyManager> tManager,
bool defaultFallback);
/**
* Container to own the SSLContext, SSLSessionCacheManager and
* TLSTicketKeyManager.
*/
std::vector<std::shared_ptr<SSLContext>> ctxs_;
std::vector<std::unique_ptr<SSLSessionCacheManager>>
sessionCacheManagers_;
std::vector<std::unique_ptr<TLSTicketKeyManager>> ticketManagers_;
std::shared_ptr<SSLContext> defaultCtx_;
/**
* Container to store the (DomainName -> SSL_CTX) mapping
*/
std::unordered_map<
DNString,
std::shared_ptr<SSLContext>,
DNStringHash> dnMap_;
EventBase* eventBase_;
ClientHelloExtStats* clientHelloTLSExtStats_{nullptr};
SSLContextConfig::SNINoMatchFn noMatchFn_;
bool strict_{true};
};
} // namespace
folly/wangle/ssl/SSLSessionCacheManager.cpp deleted 100644 → 0
View file @ a716b86b
/*
* Copyright (c) 2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
*/
#include <folly/wangle/ssl/SSLSessionCacheManager.h>
#include <folly/wangle/ssl/SSLCacheProvider.h>
#include <folly/wangle/ssl/SSLStats.h>
#include <folly/wangle/ssl/SSLUtil.h>
#include <folly/io/async/EventBase.h>
#ifndef NO_LIB_GFLAGS
#include <gflags/gflags.h>
#endif
using std::string;
using std::shared_ptr;
namespace {
const uint32_t NUM_CACHE_BUCKETS = 16;
// We use the default ID generator which fills the maximum ID length
// for the protocol. 16 bytes for SSLv2 or 32 for SSLv3+
const int MIN_SESSION_ID_LENGTH = 16;
}
#ifndef NO_LIB_GFLAGS
DEFINE_bool(dcache_unit_test, false, "All VIPs share one session cache");
#else
const bool FLAGS_dcache_unit_test = false;
#endif
namespace folly {
int SSLSessionCacheManager::sExDataIndex_ = -1;
shared_ptr<ShardedLocalSSLSessionCache> SSLSessionCacheManager::sCache_;
std::mutex SSLSessionCacheManager::sCacheLock_;
LocalSSLSessionCache::LocalSSLSessionCache(uint32_t maxCacheSize,
uint32_t cacheCullSize)
: sessionCache(maxCacheSize, cacheCullSize) {
sessionCache.setPruneHook(std::bind(
&LocalSSLSessionCache::pruneSessionCallback,
this, std::placeholders::_1,
std::placeholders::_2));
}
void LocalSSLSessionCache::pruneSessionCallback(const string& sessionId,
SSL_SESSION* session) {
VLOG(4) << "Free SSL session from local cache; id="
<< SSLUtil::hexlify(sessionId);
SSL_SESSION_free(session);
++removedSessions_;
}
// SSLSessionCacheManager implementation
SSLSessionCacheManager::SSLSessionCacheManager(
uint32_t maxCacheSize,
uint32_t cacheCullSize,
SSLContext* ctx,
const folly::SocketAddress& sockaddr,
const string& context,
EventBase* eventBase,
SSLStats* stats,
const std::shared_ptr<SSLCacheProvider>& externalCache):
ctx_(ctx),
stats_(stats),
externalCache_(externalCache) {
SSL_CTX* sslCtx = ctx->getSSLCtx();
SSLUtil::getSSLCtxExIndex(&sExDataIndex_);
SSL_CTX_set_ex_data(sslCtx, sExDataIndex_, this);
SSL_CTX_sess_set_new_cb(sslCtx, SSLSessionCacheManager::newSessionCallback);
SSL_CTX_sess_set_get_cb(sslCtx, SSLSessionCacheManager::getSessionCallback);
SSL_CTX_sess_set_remove_cb(sslCtx,
SSLSessionCacheManager::removeSessionCallback);
if (!FLAGS_dcache_unit_test && !context.empty()) {
// Use the passed in context
SSL_CTX_set_session_id_context(sslCtx, (const uint8_t *)context.data(),
std::min((int)context.length(),
SSL_MAX_SSL_SESSION_ID_LENGTH));
}
SSL_CTX_set_session_cache_mode(sslCtx, SSL_SESS_CACHE_NO_INTERNAL
| SSL_SESS_CACHE_SERVER);
localCache_ = SSLSessionCacheManager::getLocalCache(maxCacheSize,
cacheCullSize);
VLOG(2) << "On VipID=" << sockaddr.describe() << " context=" << context;
}
SSLSessionCacheManager::~SSLSessionCacheManager() {
}
void SSLSessionCacheManager::shutdown() {
std::lock_guard<std::mutex> g(sCacheLock_);
sCache_.reset();
}
shared_ptr<ShardedLocalSSLSessionCache> SSLSessionCacheManager::getLocalCache(
uint32_t maxCacheSize,
uint32_t cacheCullSize) {
std::lock_guard<std::mutex> g(sCacheLock_);
if (!sCache_) {
sCache_.reset(new ShardedLocalSSLSessionCache(NUM_CACHE_BUCKETS,
maxCacheSize,
cacheCullSize));
}
return sCache_;
}
int SSLSessionCacheManager::newSessionCallback(SSL* ssl, SSL_SESSION* session) {
SSLSessionCacheManager* manager = nullptr;
SSL_CTX* ctx = SSL_get_SSL_CTX(ssl);
manager = (SSLSessionCacheManager *)SSL_CTX_get_ex_data(ctx, sExDataIndex_);
if (manager == nullptr) {
LOG(FATAL) << "Null SSLSessionCacheManager in callback";
return -1;
}
return manager->newSession(ssl, session);
}
int SSLSessionCacheManager::newSession(SSL* ssl, SSL_SESSION* session) {
string sessionId((char*)session->session_id, session->session_id_length);
VLOG(4) << "New SSL session; id=" << SSLUtil::hexlify(sessionId);
if (stats_) {
stats_->recordSSLSession(true /* new session */, false, false);
}
localCache_->storeSession(sessionId, session, stats_);
if (externalCache_) {
VLOG(4) << "New SSL session: send session to external cache; id=" <<
SSLUtil::hexlify(sessionId);
storeCacheRecord(sessionId, session);
}
return 1;
}
void SSLSessionCacheManager::removeSessionCallback(SSL_CTX* ctx,
SSL_SESSION* session) {
SSLSessionCacheManager* manager = nullptr;
manager = (SSLSessionCacheManager *)SSL_CTX_get_ex_data(ctx, sExDataIndex_);
if (manager == nullptr) {
LOG(FATAL) << "Null SSLSessionCacheManager in callback";
return;
}
return manager->removeSession(ctx, session);
}
void SSLSessionCacheManager::removeSession(SSL_CTX* ctx,
SSL_SESSION* session) {
string sessionId((char*)session->session_id, session->session_id_length);
// This hook is only called from SSL when the internal session cache needs to
// flush sessions. Since we run with the internal cache disabled, this should
// never be called
VLOG(3) << "Remove SSL session; id=" << SSLUtil::hexlify(sessionId);
localCache_->removeSession(sessionId);
if (stats_) {
stats_->recordSSLSessionRemove();
}
}
SSL_SESSION* SSLSessionCacheManager::getSessionCallback(SSL* ssl,
unsigned char* sess_id,
int id_len,
int* copyflag) {
SSLSessionCacheManager* manager = nullptr;
SSL_CTX* ctx = SSL_get_SSL_CTX(ssl);
manager = (SSLSessionCacheManager *)SSL_CTX_get_ex_data(ctx, sExDataIndex_);
if (manager == nullptr) {
LOG(FATAL) << "Null SSLSessionCacheManager in callback";
return nullptr;
}
return manager->getSession(ssl, sess_id, id_len, copyflag);
}
SSL_SESSION* SSLSessionCacheManager::getSession(SSL* ssl,
unsigned char* session_id,
int id_len,
int* copyflag) {
VLOG(7) << "SSL get session callback";
SSL_SESSION* session = nullptr;
bool foreign = false;
char const* missReason = nullptr;
if (id_len < MIN_SESSION_ID_LENGTH) {
// We didn't generate this session so it's going to be a miss.
// This doesn't get logged or counted in the stats.
return nullptr;
}
string sessionId((char*)session_id, id_len);
AsyncSSLSocket* sslSocket = AsyncSSLSocket::getFromSSL(ssl);
assert(sslSocket != nullptr);
// look it up in the local cache first
session = localCache_->lookupSession(sessionId);
#ifdef SSL_SESSION_CB_WOULD_BLOCK
if (session == nullptr && externalCache_) {
// external cache might have the session
foreign = true;
if (!SSL_want_sess_cache_lookup(ssl)) {
missReason = "reason: No async cache support;";
} else {
PendingLookupMap::iterator pit = pendingLookups_.find(sessionId);
if (pit == pendingLookups_.end()) {
auto result = pendingLookups_.emplace(sessionId, PendingLookup());
// initiate fetch
VLOG(4) << "Get SSL session [Pending]: Initiate Fetch; fd=" <<
sslSocket->getFd() << " id=" << SSLUtil::hexlify(sessionId);
if (lookupCacheRecord(sessionId, sslSocket)) {
// response is pending
*copyflag = SSL_SESSION_CB_WOULD_BLOCK;
return nullptr;
} else {
missReason = "reason: failed to send lookup request;";
pendingLookups_.erase(result.first);
}
} else {
// A lookup was already initiated from this thread
if (pit->second.request_in_progress) {
// Someone else initiated the request, attach
VLOG(4) << "Get SSL session [Pending]: Request in progess: attach; "
"fd=" << sslSocket->getFd() << " id=" <<
SSLUtil::hexlify(sessionId);
std::unique_ptr<DelayedDestruction::DestructorGuard> dg(
new DelayedDestruction::DestructorGuard(sslSocket));
pit->second.waiters.push_back(
std::make_pair(sslSocket, std::move(dg)));
*copyflag = SSL_SESSION_CB_WOULD_BLOCK;
return nullptr;
}
// request is complete
session = pit->second.session; // nullptr if our friend didn't have it
if (session != nullptr) {
CRYPTO_add(&session->references, 1, CRYPTO_LOCK_SSL_SESSION);
}
}
}
}
#endif
bool hit = (session != nullptr);
if (stats_) {
stats_->recordSSLSession(false, hit, foreign);
}
if (hit) {
sslSocket->setSessionIDResumed(true);
}
VLOG(4) << "Get SSL session [" <<
((hit) ? "Hit" : "Miss") << "]: " <<
((foreign) ? "external" : "local") << " cache; " <<
((missReason != nullptr) ? missReason : "") << "fd=" <<
sslSocket->getFd() << " id=" << SSLUtil::hexlify(sessionId);
// We already bumped the refcount
*copyflag = 0;
return session;
}
bool SSLSessionCacheManager::storeCacheRecord(const string& sessionId,
SSL_SESSION* session) {
std::string sessionString;
uint32_t sessionLen = i2d_SSL_SESSION(session, nullptr);
sessionString.resize(sessionLen);
uint8_t* cp = (uint8_t *)sessionString.data();
i2d_SSL_SESSION(session, &cp);
size_t expiration = SSL_CTX_get_timeout(ctx_->getSSLCtx());
return externalCache_->setAsync(sessionId, sessionString,
std::chrono::seconds(expiration));
}
bool SSLSessionCacheManager::lookupCacheRecord(const string& sessionId,
AsyncSSLSocket* sslSocket) {
auto cacheCtx = new SSLCacheProvider::CacheContext();
cacheCtx->sessionId = sessionId;
cacheCtx->session = nullptr;
cacheCtx->sslSocket = sslSocket;
cacheCtx->guard.reset(
new DelayedDestruction::DestructorGuard(cacheCtx->sslSocket));
cacheCtx->manager = this;
bool res = externalCache_->getAsync(sessionId, cacheCtx);
if (!res) {
delete cacheCtx;
}
return res;
}
void SSLSessionCacheManager::restartSSLAccept(
const SSLCacheProvider::CacheContext* cacheCtx) {
PendingLookupMap::iterator pit = pendingLookups_.find(cacheCtx->sessionId);
CHECK(pit != pendingLookups_.end());
pit->second.request_in_progress = false;
pit->second.session = cacheCtx->session;
VLOG(7) << "Restart SSL accept";
cacheCtx->sslSocket->restartSSLAccept();
for (const auto& attachedLookup: pit->second.waiters) {
// Wake up anyone else who was waiting for this session
VLOG(4) << "Restart SSL accept (waiters) for fd=" <<
attachedLookup.first->getFd();
attachedLookup.first->restartSSLAccept();
}
pendingLookups_.erase(pit);
}
void SSLSessionCacheManager::onGetSuccess(
SSLCacheProvider::CacheContext* cacheCtx,
const std::string& value) {
const uint8_t* cp = (uint8_t*)value.data();
cacheCtx->session = d2i_SSL_SESSION(nullptr, &cp, value.length());
restartSSLAccept(cacheCtx);
/* Insert in the LRU after restarting all clients. The stats logic
* in getSession would treat this as a local hit otherwise.
*/
localCache_->storeSession(cacheCtx->sessionId, cacheCtx->session, stats_);
delete cacheCtx;
}
void SSLSessionCacheManager::onGetFailure(
SSLCacheProvider::CacheContext* cacheCtx) {
restartSSLAccept(cacheCtx);
delete cacheCtx;
}
} // namespace
folly/wangle/ssl/SSLSessionCacheManager.h deleted 100644 → 0
View file @ a716b86b
/*
* Copyright (c) 2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
*/
#pragma once
#include <folly/wangle/ssl/SSLCacheProvider.h>
#include <folly/wangle/ssl/SSLStats.h>
#include <folly/EvictingCacheMap.h>
#include <mutex>
#include <folly/io/async/AsyncSSLSocket.h>
namespace folly {
class SSLStats;
/**
* Basic SSL session cache map: Maps session id -> session
*/
typedef folly::EvictingCacheMap<std::string, SSL_SESSION*> SSLSessionCacheMap;
/**
* Holds an SSLSessionCacheMap and associated lock
*/
class LocalSSLSessionCache: private boost::noncopyable {
public:
LocalSSLSessionCache(uint32_t maxCacheSize, uint32_t cacheCullSize);
~LocalSSLSessionCache() {
std::lock_guard<std::mutex> g(lock);
// EvictingCacheMap dtor doesn't free values
sessionCache.clear();
}
SSLSessionCacheMap sessionCache;
std::mutex lock;
uint32_t removedSessions_{0};
private:
void pruneSessionCallback(const std::string& sessionId,
SSL_SESSION* session);
};
/**
* 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.
*/
class ShardedLocalSSLSessionCache : private boost::noncopyable {
public:
ShardedLocalSSLSessionCache(uint32_t n_buckets, uint32_t maxCacheSize,
uint32_t cacheCullSize) {
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)));
}
}
SSL_SESSION* lookupSession(const std::string& sessionId) {
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) {
CRYPTO_add(&session->references, 1, CRYPTO_LOCK_SSL_SESSION);
}
return session;
}
void storeSession(const std::string& sessionId, SSL_SESSION* session,
SSLStats* stats) {
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_);
}
}
void removeSession(const std::string& sessionId) {
size_t bucket = hash(sessionId);
std::lock_guard<std::mutex> g(caches_[bucket]->lock);
caches_[bucket]->sessionCache.erase(sessionId);
}
private:
/* SSL session IDs are 32 bytes of random data, hash based on first 16 bits */
size_t hash(const std::string& key) {
CHECK(key.length() >= 2);
return (key[0] << 8 | key[1]) % caches_.size();
}
std::vector< std::unique_ptr<LocalSSLSessionCache> > caches_;
};
/* A socket/DestructorGuard pair */
typedef std::pair<AsyncSSLSocket *,
std::unique_ptr<DelayedDestruction::DestructorGuard>>
AttachedLookup;
/**
* PendingLookup structure
*
* Keeps track of clients waiting for an SSL session to be retrieved from
* the external cache provider.
*/
struct PendingLookup {
bool request_in_progress;
SSL_SESSION* session;
std::list<AttachedLookup> waiters;
PendingLookup() {
request_in_progress = true;
session = nullptr;
}
};
/* Maps SSL session id to a PendingLookup structure */
typedef std::map<std::string, PendingLookup> PendingLookupMap;
/**
* SSLSessionCacheManager handles all stateful session caching. There is an
* instance of this object per SSL VIP per thread, with a 1:1 correlation with
* SSL_CTX. The cache can work locally or in concert with an external cache
* to share sessions across instances.
*
* There is a single in memory session cache shared by all VIPs. The cache is
* split into N buckets (currently 16) with a separate lock per bucket. The
* VIP ID is hashed and stored as part of the session to handle the
* (very unlikely) case of session ID collision.
*
* When a new SSL session is created, it is added to the LRU cache and
* sent to the external cache to be stored. The external cache
* expiration is equal to the SSL session's expiration.
*
* When a resume request is received, SSLSessionCacheManager first looks in the
* local LRU cache for the VIP. If there is a miss there, an asynchronous
* request for this session is dispatched to the external cache. When the
* external cache query returns, the LRU cache is updated if the session was
* found, and the SSL_accept call is resumed.
*
* If additional resume requests for the same session ID arrive in the same
* thread while the request is pending, the 2nd - Nth callers attach to the
* original external cache requests and are resumed when it comes back. No
* attempt is made to coalesce external cache requests for the same session
* ID in different worker threads. Previous work did this, but the
* complexity was deemed to outweigh the potential savings.
*
*/
class SSLSessionCacheManager : private boost::noncopyable {
public:
/**
* Constructor. SSL session related callbacks will be set on the underlying
* SSL_CTX. vipId is assumed to a unique string identifying the VIP and must
* be the same on all servers that wish to share sessions via the same
* external cache.
*/
SSLSessionCacheManager(
uint32_t maxCacheSize,
uint32_t cacheCullSize,
SSLContext* ctx,
const folly::SocketAddress& sockaddr,
const std::string& context,
EventBase* eventBase,
SSLStats* stats,
const std::shared_ptr<SSLCacheProvider>& externalCache);
virtual ~SSLSessionCacheManager();
/**
* Call this on shutdown to release the global instance of the
* ShardedLocalSSLSessionCache.
*/
static void shutdown();
/**
* Callback for ExternalCache to call when an async get succeeds
* @param context The context that was passed to the async get request
* @param value Serialized session
*/
void onGetSuccess(SSLCacheProvider::CacheContext* context,
const std::string& value);
/**
* Callback for ExternalCache to call when an async get fails, either
* because the requested session is not in the external cache or because
* of an error.
* @param context The context that was passed to the async get request
*/
void onGetFailure(SSLCacheProvider::CacheContext* context);
private:
SSLContext* ctx_;
std::shared_ptr<ShardedLocalSSLSessionCache> localCache_;
PendingLookupMap pendingLookups_;
SSLStats* stats_{nullptr};
std::shared_ptr<SSLCacheProvider> externalCache_;
/**
* Invoked by openssl when a new SSL session is created
*/
int newSession(SSL* ssl, SSL_SESSION* session);
/**
* Invoked by openssl when an SSL session is ejected from its internal cache.
* This can't be invoked in the current implementation because SSL's internal
* caching is disabled.
*/
void removeSession(SSL_CTX* ctx, SSL_SESSION* session);
/**
* Invoked by openssl when a client requests a stateful session resumption.
* Triggers a lookup in our local cache and potentially an asynchronous
* request to an external cache.
*/
SSL_SESSION* getSession(SSL* ssl, unsigned char* session_id,
int id_len, int* copyflag);
/**
* Store a new session record in the external cache
*/
bool storeCacheRecord(const std::string& sessionId, SSL_SESSION* session);
/**
* Lookup a session in the external cache for the specified SSL socket.
*/
bool lookupCacheRecord(const std::string& sessionId,
AsyncSSLSocket* sslSock);
/**
* Restart all clients waiting for the answer to an external cache query
*/
void restartSSLAccept(const SSLCacheProvider::CacheContext* cacheCtx);
/**
* Get or create the LRU cache for the given VIP ID
*/
static std::shared_ptr<ShardedLocalSSLSessionCache> getLocalCache(
uint32_t maxCacheSize, uint32_t cacheCullSize);
/**
* static functions registered as callbacks to openssl via
* SSL_CTX_sess_set_new/get/remove_cb
*/
static int newSessionCallback(SSL* ssl, SSL_SESSION* session);
static void removeSessionCallback(SSL_CTX* ctx, SSL_SESSION* session);
static SSL_SESSION* getSessionCallback(SSL* ssl, unsigned char* session_id,
int id_len, int* copyflag);
static int32_t sExDataIndex_;
static std::shared_ptr<ShardedLocalSSLSessionCache> sCache_;
static std::mutex sCacheLock_;
};
}
folly/wangle/ssl/SSLStats.h deleted 100644 → 0
View file @ a716b86b
/*
* Copyright (c) 2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
*/
#pragma once
namespace folly {
class SSLStats {
public:
virtual ~SSLStats() noexcept {}
// downstream
virtual void recordSSLAcceptLatency(int64_t latency) noexcept = 0;
virtual void recordTLSTicket(bool ticketNew, bool ticketHit) noexcept = 0;
virtual void recordSSLSession(bool sessionNew, bool sessionHit, bool foreign)
noexcept = 0;
virtual void recordSSLSessionRemove() noexcept = 0;
virtual void recordSSLSessionFree(uint32_t freed) noexcept = 0;
virtual void recordSSLSessionSetError(uint32_t err) noexcept = 0;
virtual void recordSSLSessionGetError(uint32_t err) noexcept = 0;
virtual void recordClientRenegotiation() noexcept = 0;
// upstream
virtual void recordSSLUpstreamConnection(bool handshake) noexcept = 0;
virtual void recordSSLUpstreamConnectionError(bool verifyError) noexcept = 0;
virtual void recordCryptoSSLExternalAttempt() noexcept = 0;
virtual void recordCryptoSSLExternalConnAlreadyClosed() noexcept = 0;
virtual void recordCryptoSSLExternalApplicationException() noexcept = 0;
virtual void recordCryptoSSLExternalSuccess() noexcept = 0;
virtual void recordCryptoSSLExternalDuration(uint64_t duration) noexcept = 0;
virtual void recordCryptoSSLLocalAttempt() noexcept = 0;
virtual void recordCryptoSSLLocalSuccess() noexcept = 0;
};
}
folly/wangle/ssl/SSLUtil.cpp deleted 100644 → 0
View file @ a716b86b
/*
* Copyright (c) 2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
*/
#include <folly/wangle/ssl/SSLUtil.h>
#include <folly/Memory.h>
#if OPENSSL_VERSION_NUMBER >= 0x1000105fL
#define OPENSSL_GE_101 1
#include <openssl/asn1.h>
#include <openssl/x509v3.h>
#else
#undef OPENSSL_GE_101
#endif
namespace folly {
std::mutex SSLUtil::sIndexLock_;
std::unique_ptr<std::string> SSLUtil::getCommonName(const X509* cert) {
X509_NAME* subject = X509_get_subject_name((X509*)cert);
if (!subject) {
return nullptr;
}
char cn[ub_common_name + 1];
int res = X509_NAME_get_text_by_NID(subject, NID_commonName,
cn, ub_common_name);
if (res <= 0) {
return nullptr;
} else {
cn[ub_common_name] = '\0';
return folly::make_unique<std::string>(cn);
}
}
std::unique_ptr<std::list<std::string>> SSLUtil::getSubjectAltName(
const X509* cert) {
#ifdef OPENSSL_GE_101
auto nameList = folly::make_unique<std::list<std::string>>();
GENERAL_NAMES* names = (GENERAL_NAMES*)X509_get_ext_d2i(
(X509*)cert, NID_subject_alt_name, nullptr, nullptr);
if (names) {
auto guard = folly::makeGuard([names] { GENERAL_NAMES_free(names); });
size_t count = sk_GENERAL_NAME_num(names);
CHECK(count < std::numeric_limits<int>::max());
for (int i = 0; i < (int)count; ++i) {
GENERAL_NAME* generalName = sk_GENERAL_NAME_value(names, i);
if (generalName->type == GEN_DNS) {
ASN1_STRING* s = generalName->d.dNSName;
const char* name = (const char*)ASN1_STRING_data(s);
// I can't find any docs on what a negative return value here
// would mean, so I'm going to ignore it.
auto len = ASN1_STRING_length(s);
DCHECK(len >= 0);
if (size_t(len) != strlen(name)) {
// Null byte(s) in the name; return an error rather than depending on
// the caller to safely handle this case.
return nullptr;
}
nameList->emplace_back(name);
}
}
}
return nameList;
#else
return nullptr;
#endif
}
}
folly/wangle/ssl/SSLUtil.h deleted 100644 → 0
View file @ a716b86b
/*
* Copyright (c) 2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
*/
#pragma once
#include <folly/String.h>
#include <mutex>
#include <folly/io/async/AsyncSSLSocket.h>
namespace folly {
/**
* SSL session establish/resume status
*
* changing these values will break logging pipelines
*/
enum class SSLResumeEnum : uint8_t {
HANDSHAKE = 0,
RESUME_SESSION_ID = 1,
RESUME_TICKET = 3,
NA = 2
};
enum class SSLErrorEnum {
NO_ERROR,
TIMEOUT,
DROPPED
};
class SSLUtil {
private:
static std::mutex sIndexLock_;
public:
/**
* Ensures only one caller will allocate an ex_data index for a given static
* or global.
*/
static void getSSLCtxExIndex(int* pindex) {
std::lock_guard<std::mutex> g(sIndexLock_);
if (*pindex < 0) {
*pindex = SSL_CTX_get_ex_new_index(0, nullptr, nullptr, nullptr, nullptr);
}
}
static void getRSAExIndex(int* pindex) {
std::lock_guard<std::mutex> g(sIndexLock_);
if (*pindex < 0) {
*pindex = RSA_get_ex_new_index(0, nullptr, nullptr, nullptr, nullptr);
}
}
static inline std::string hexlify(const std::string& binary) {
std::string hex;
folly::hexlify<std::string, std::string>(binary, hex);
return hex;
}
static inline const std::string& hexlify(const std::string& binary,
std::string& hex) {
folly::hexlify<std::string, std::string>(binary, hex);
return hex;
}
/**
* Return the SSL resume type for the given socket.
*/
static inline SSLResumeEnum getResumeState(
AsyncSSLSocket* sslSocket) {
return sslSocket->getSSLSessionReused() ?
(sslSocket->sessionIDResumed() ?
SSLResumeEnum::RESUME_SESSION_ID :
SSLResumeEnum::RESUME_TICKET) :
SSLResumeEnum::HANDSHAKE;
}
/**
* Get the Common Name from an X.509 certificate
* @param cert certificate to inspect
* @return common name, or null if an error occurs
*/
static std::unique_ptr<std::string> getCommonName(const X509* cert);
/**
* Get the Subject Alternative Name value(s) from an X.509 certificate
* @param cert certificate to inspect
* @return set of zero or more alternative names, or null if
* an error occurs
*/
static std::unique_ptr<std::list<std::string>> getSubjectAltName(
const X509* cert);
};
}
folly/wangle/ssl/TLSTicketKeyManager.cpp deleted 100644 → 0
View file @ a716b86b
/*
* Copyright (c) 2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
*/
#include <folly/wangle/ssl/TLSTicketKeyManager.h>
#include <folly/wangle/ssl/SSLStats.h>
#include <folly/wangle/ssl/SSLUtil.h>
#include <folly/String.h>
#include <openssl/aes.h>
#include <openssl/rand.h>
#include <openssl/ssl.h>
#include <folly/io/async/AsyncTimeout.h>
#ifdef SSL_CTRL_SET_TLSEXT_TICKET_KEY_CB
using std::string;
namespace {
const int kTLSTicketKeyNameLen = 4;
const int kTLSTicketKeySaltLen = 12;
}
namespace folly {
// TLSTicketKeyManager Implementation
int32_t TLSTicketKeyManager::sExDataIndex_ = -1;
TLSTicketKeyManager::TLSTicketKeyManager(SSLContext* ctx, SSLStats* stats)
: ctx_(ctx),
randState_(0),
stats_(stats) {
SSLUtil::getSSLCtxExIndex(&sExDataIndex_);
SSL_CTX_set_ex_data(ctx_->getSSLCtx(), sExDataIndex_, this);
}
TLSTicketKeyManager::~TLSTicketKeyManager() {
}
int
TLSTicketKeyManager::callback(SSL* ssl, unsigned char* keyName,
unsigned char* iv,
EVP_CIPHER_CTX* cipherCtx,
HMAC_CTX* hmacCtx, int encrypt) {
TLSTicketKeyManager* manager = nullptr;
SSL_CTX* ctx = SSL_get_SSL_CTX(ssl);
manager = (TLSTicketKeyManager *)SSL_CTX_get_ex_data(ctx, sExDataIndex_);
if (manager == nullptr) {
LOG(FATAL) << "Null TLSTicketKeyManager in callback" ;
return -1;
}
return manager->processTicket(ssl, keyName, iv, cipherCtx, hmacCtx, encrypt);
}
int
TLSTicketKeyManager::processTicket(SSL* ssl, unsigned char* keyName,
unsigned char* iv,
EVP_CIPHER_CTX* cipherCtx,
HMAC_CTX* hmacCtx, int encrypt) {
uint8_t salt[kTLSTicketKeySaltLen];
uint8_t* saltptr = nullptr;
uint8_t output[SHA256_DIGEST_LENGTH];
uint8_t* hmacKey = nullptr;
uint8_t* aesKey = nullptr;
TLSTicketKeySource* key = nullptr;
int result = 0;
if (encrypt) {
key = findEncryptionKey();
if (key == nullptr) {
// no keys available to encrypt
VLOG(2) << "No TLS ticket key found";
return -1;
}
VLOG(4) << "Encrypting new ticket with key name=" <<
SSLUtil::hexlify(key->keyName_);
// Get a random salt and write out key name
RAND_pseudo_bytes(salt, (int)sizeof(salt));
memcpy(keyName, key->keyName_.data(), kTLSTicketKeyNameLen);
memcpy(keyName + kTLSTicketKeyNameLen, salt, kTLSTicketKeySaltLen);
// Create the unique keys by hashing with the salt
makeUniqueKeys(key->keySource_, sizeof(key->keySource_), salt, output);
// This relies on the fact that SHA256 has 32 bytes of output
// and that AES-128 keys are 16 bytes
hmacKey = output;
aesKey = output + SHA256_DIGEST_LENGTH / 2;
// Initialize iv and cipher/mac CTX
RAND_pseudo_bytes(iv, AES_BLOCK_SIZE);
HMAC_Init_ex(hmacCtx, hmacKey, SHA256_DIGEST_LENGTH / 2,
EVP_sha256(), nullptr);
EVP_EncryptInit_ex(cipherCtx, EVP_aes_128_cbc(), nullptr, aesKey, iv);
result = 1;
} else {
key = findDecryptionKey(keyName);
if (key == nullptr) {
// no ticket found for decryption - will issue a new ticket
if (VLOG_IS_ON(4)) {
string skeyName((char *)keyName, kTLSTicketKeyNameLen);
VLOG(4) << "Can't find ticket key with name=" <<
SSLUtil::hexlify(skeyName)<< ", will generate new ticket";
}
result = 0;
} else {
VLOG(4) << "Decrypting ticket with key name=" <<
SSLUtil::hexlify(key->keyName_);
// Reconstruct the unique key via the salt
saltptr = keyName + kTLSTicketKeyNameLen;
makeUniqueKeys(key->keySource_, sizeof(key->keySource_), saltptr, output);
hmacKey = output;
aesKey = output + SHA256_DIGEST_LENGTH / 2;
// Initialize cipher/mac CTX
HMAC_Init_ex(hmacCtx, hmacKey, SHA256_DIGEST_LENGTH / 2,
EVP_sha256(), nullptr);
EVP_DecryptInit_ex(cipherCtx, EVP_aes_128_cbc(), nullptr, aesKey, iv);
result = 1;
}
}
// result records whether a ticket key was found to decrypt this ticket,
// not wether the session was re-used.
if (stats_) {
stats_->recordTLSTicket(encrypt, result);
}
return result;
}
bool
TLSTicketKeyManager::setTLSTicketKeySeeds(
const std::vector<std::string>& oldSeeds,
const std::vector<std::string>& currentSeeds,
const std::vector<std::string>& newSeeds) {
bool result = true;
activeKeys_.clear();
ticketKeys_.clear();
ticketSeeds_.clear();
const std::vector<string> *seedList = &oldSeeds;
for (uint32_t i = 0; i < 3; i++) {
TLSTicketSeedType type = (TLSTicketSeedType)i;
if (type == SEED_CURRENT) {
seedList = &currentSeeds;
} else if (type == SEED_NEW) {
seedList = &newSeeds;
}
for (const auto& seedInput: *seedList) {
TLSTicketSeed* seed = insertSeed(seedInput, type);
if (seed == nullptr) {
result = false;
continue;
}
insertNewKey(seed, 1, nullptr);
}
}
if (!result) {
VLOG(2) << "One or more seeds failed to decode";
}
if (ticketKeys_.size() == 0 || activeKeys_.size() == 0) {
LOG(WARNING) << "No keys configured, falling back to default";
SSL_CTX_set_tlsext_ticket_key_cb(ctx_->getSSLCtx(), nullptr);
return false;
}
SSL_CTX_set_tlsext_ticket_key_cb(ctx_->getSSLCtx(),
TLSTicketKeyManager::callback);
return true;
}
string
TLSTicketKeyManager::makeKeyName(TLSTicketSeed* seed, uint32_t n,
unsigned char* nameBuf) {
SHA256_CTX ctx;
SHA256_Init(&ctx);
SHA256_Update(&ctx, seed->seedName_, sizeof(seed->seedName_));
SHA256_Update(&ctx, &n, sizeof(n));
SHA256_Final(nameBuf, &ctx);
return string((char *)nameBuf, kTLSTicketKeyNameLen);
}
TLSTicketKeyManager::TLSTicketKeySource*
TLSTicketKeyManager::insertNewKey(TLSTicketSeed* seed, uint32_t hashCount,
TLSTicketKeySource* prevKey) {
unsigned char nameBuf[SHA256_DIGEST_LENGTH];
std::unique_ptr<TLSTicketKeySource> newKey(new TLSTicketKeySource);
// This function supports hash chaining but it is not currently used.
if (prevKey != nullptr) {
hashNth(prevKey->keySource_, sizeof(prevKey->keySource_),
newKey->keySource_, 1);
} else {
// can't go backwards or the current is missing, start from the beginning
hashNth((unsigned char *)seed->seed_.data(), seed->seed_.length(),
newKey->keySource_, hashCount);
}
newKey->hashCount_ = hashCount;
newKey->keyName_ = makeKeyName(seed, hashCount, nameBuf);
newKey->type_ = seed->type_;
auto it = ticketKeys_.insert(std::make_pair(newKey->keyName_,
std::move(newKey)));
auto key = it.first->second.get();
if (key->type_ == SEED_CURRENT) {
activeKeys_.push_back(key);
}
VLOG(4) << "Adding key for " << hashCount << " type=" <<
(uint32_t)key->type_ << " Name=" << SSLUtil::hexlify(key->keyName_);
return key;
}
void
TLSTicketKeyManager::hashNth(const unsigned char* input, size_t input_len,
unsigned char* output, uint32_t n) {
assert(n > 0);
for (uint32_t i = 0; i < n; i++) {
SHA256(input, input_len, output);
input = output;
input_len = SHA256_DIGEST_LENGTH;
}
}
TLSTicketKeyManager::TLSTicketSeed *
TLSTicketKeyManager::insertSeed(const string& seedInput,
TLSTicketSeedType type) {
TLSTicketSeed* seed = nullptr;
string seedOutput;
if (!folly::unhexlify<string, string>(seedInput, seedOutput)) {
LOG(WARNING) << "Failed to decode seed type=" << (uint32_t)type <<
" seed=" << seedInput;
return seed;
}
seed = new TLSTicketSeed();
seed->seed_ = seedOutput;
seed->type_ = type;
SHA256((unsigned char *)seedOutput.data(), seedOutput.length(),
seed->seedName_);
ticketSeeds_.push_back(std::unique_ptr<TLSTicketSeed>(seed));
return seed;
}
TLSTicketKeyManager::TLSTicketKeySource *
TLSTicketKeyManager::findEncryptionKey() {
TLSTicketKeySource* result = nullptr;
// call to rand here is a bit hokey since it's not cryptographically
// random, and is predictably seeded with 0. However, activeKeys_
// is probably not going to have very many keys in it, and most
// likely only 1.
size_t numKeys = activeKeys_.size();
if (numKeys > 0) {
result = activeKeys_[rand_r(&randState_) % numKeys];
}
return result;
}
TLSTicketKeyManager::TLSTicketKeySource *
TLSTicketKeyManager::findDecryptionKey(unsigned char* keyName) {
string name((char *)keyName, kTLSTicketKeyNameLen);
TLSTicketKeySource* key = nullptr;
TLSTicketKeyMap::iterator mapit = ticketKeys_.find(name);
if (mapit != ticketKeys_.end()) {
key = mapit->second.get();
}
return key;
}
void
TLSTicketKeyManager::makeUniqueKeys(unsigned char* parentKey,
size_t keyLen,
unsigned char* salt,
unsigned char* output) {
SHA256_CTX hash_ctx;
SHA256_Init(&hash_ctx);
SHA256_Update(&hash_ctx, parentKey, keyLen);
SHA256_Update(&hash_ctx, salt, kTLSTicketKeySaltLen);
SHA256_Final(output, &hash_ctx);
}
} // namespace
#endif
folly/wangle/ssl/TLSTicketKeyManager.h deleted 100644 → 0
View file @ a716b86b
/*
* Copyright (c) 2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
*/
#pragma once
#include <folly/io/async/SSLContext.h>
#include <folly/io/async/EventBase.h>
namespace folly {
#ifndef SSL_CTRL_SET_TLSEXT_TICKET_KEY_CB
class TLSTicketKeyManager {};
#else
class SSLStats;
/**
* The TLSTicketKeyManager handles TLS ticket key encryption and decryption in
* a way that facilitates sharing the ticket keys across a range of servers.
* Hash chaining is employed to achieve frequent key rotation with minimal
* configuration change. The scheme is as follows:
*
* The manager is supplied with three lists of seeds (old, current and new).
* The config should be updated with new seeds periodically (e.g., daily).
* 3 config changes are recommended to achieve the smoothest seed rotation
* eg:
* 1. Introduce new seed in the push prior to rotation
* 2. Rotation push
* 3. Remove old seeds in the push following rotation
*
* Multiple seeds are supported but only a single seed is required.
*
* Generating encryption keys from the seed works as follows. For a given
* seed, hash forward N times where N is currently the constant 1.
* This is the base key. The name of the base key is the first 4
* bytes of hash(hash(seed), N). This is copied into the first 4 bytes of the
* TLS ticket key name field.
*
* For each new ticket encryption, the manager generates a random 12 byte salt.
* Hash the salt and the base key together to form the encryption key for
* that ticket. The salt is included in the ticket's 'key name' field so it
* can be used to derive the decryption key. The salt is copied into the second
* 8 bytes of the TLS ticket key name field.
*
* A key is valid for decryption for the lifetime of the instance.
* Sessions will be valid for less time than that, which results in an extra
* symmetric decryption to discover the session is expired.
*
* A TLSTicketKeyManager should be used in only one thread, and should have
* a 1:1 relationship with the SSLContext provided.
*
*/
class TLSTicketKeyManager : private boost::noncopyable {
public:
explicit TLSTicketKeyManager(folly::SSLContext* ctx,
SSLStats* stats);
virtual ~TLSTicketKeyManager();
/**
* SSL callback to set up encryption/decryption context for a TLS Ticket Key.
*
* This will be supplied to the SSL library via
* SSL_CTX_set_tlsext_ticket_key_cb.
*/
static int callback(SSL* ssl, unsigned char* keyName,
unsigned char* iv,
EVP_CIPHER_CTX* cipherCtx,
HMAC_CTX* hmacCtx, int encrypt);
/**
* Initialize the manager with three sets of seeds. There must be at least
* one current seed, or the manager will revert to the default SSL behavior.
*
* @param oldSeeds Seeds previously used which can still decrypt.
* @param currentSeeds Seeds to use for new ticket encryptions.
* @param newSeeds Seeds which will be used soon, can be used to decrypt
* in case some servers in the cluster have already rotated.
*/
bool setTLSTicketKeySeeds(const std::vector<std::string>& oldSeeds,
const std::vector<std::string>& currentSeeds,
const std::vector<std::string>& newSeeds);
private:
enum TLSTicketSeedType {
SEED_OLD = 0,
SEED_CURRENT,
SEED_NEW
};
/* The seeds supplied by the configuration */
struct TLSTicketSeed {
std::string seed_;
TLSTicketSeedType type_;
unsigned char seedName_[SHA256_DIGEST_LENGTH];
};
struct TLSTicketKeySource {
int32_t hashCount_;
std::string keyName_;
TLSTicketSeedType type_;
unsigned char keySource_[SHA256_DIGEST_LENGTH];
};
/**
* Method to setup encryption/decryption context for a TLS Ticket Key
*
* OpenSSL documentation is thin on the return value semantics.
*
* For encrypt=1, return < 0 on error, >= 0 for successfully initialized
* For encrypt=0, return < 0 on error, 0 on key not found
* 1 on key found, 2 renew_ticket
*
* renew_ticket means a new ticket will be issued. We could return this value
* when receiving a ticket encrypted with a key derived from an OLD seed.
* However, session_timeout seconds after deploying with a seed
* rotated from CURRENT -> OLD, there will be no valid tickets outstanding
* encrypted with the old key. This grace period means no unnecessary
* handshakes will be performed. If the seed is believed compromised, it
* should NOT be configured as an OLD seed.
*/
int processTicket(SSL* ssl, unsigned char* keyName,
unsigned char* iv,
EVP_CIPHER_CTX* cipherCtx,
HMAC_CTX* hmacCtx, int encrypt);
// Creates the name for the nth key generated from seed
std::string makeKeyName(TLSTicketSeed* seed, uint32_t n,
unsigned char* nameBuf);
/**
* Creates the key hashCount hashes from the given seed and inserts it in
* ticketKeys. A naked pointer to the key is returned for additional
* processing if needed.
*/
TLSTicketKeySource* insertNewKey(TLSTicketSeed* seed, uint32_t hashCount,
TLSTicketKeySource* prevKeySource);
/**
* hashes input N times placing result in output, which must be at least
* SHA256_DIGEST_LENGTH long.
*/
void hashNth(const unsigned char* input, size_t input_len,
unsigned char* output, uint32_t n);
/**
* Adds the given seed to the manager
*/
TLSTicketSeed* insertSeed(const std::string& seedInput,
TLSTicketSeedType type);
/**
* Locate a key for encrypting a new ticket
*/
TLSTicketKeySource* findEncryptionKey();
/**
* Locate a key for decrypting a ticket with the given keyName
*/
TLSTicketKeySource* findDecryptionKey(unsigned char* keyName);
/**
* Derive a unique key from the parent key and the salt via hashing
*/
void makeUniqueKeys(unsigned char* parentKey, size_t keyLen,
unsigned char* salt, unsigned char* output);
/**
* For standalone decryption utility
*/
friend int decrypt_fb_ticket(folly::TLSTicketKeyManager* manager,
const std::string& testTicket,
SSL_SESSION **psess);
typedef std::vector<std::unique_ptr<TLSTicketSeed>> TLSTicketSeedList;
typedef std::map<std::string, std::unique_ptr<TLSTicketKeySource> >
TLSTicketKeyMap;
typedef std::vector<TLSTicketKeySource *> TLSActiveKeyList;
TLSTicketSeedList ticketSeeds_;
// All key sources that can be used for decryption
TLSTicketKeyMap ticketKeys_;
// Key sources that can be used for encryption
TLSActiveKeyList activeKeys_;
folly::SSLContext* ctx_;
uint32_t randState_;
SSLStats* stats_{nullptr};
static int32_t sExDataIndex_;
};
#endif
}
folly/wangle/ssl/TLSTicketKeySeeds.h deleted 100644 → 0
View file @ a716b86b
/*
* Copyright (c) 2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
*/
#pragma once
namespace folly {
struct TLSTicketKeySeeds {
std::vector<std::string> oldSeeds;
std::vector<std::string> currentSeeds;
std::vector<std::string> newSeeds;
};
}
folly/wangle/ssl/test/SSLCacheTest.cpp deleted 100644 → 0
View file @ a716b86b
/*
* Copyright (c) 2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
*/
#include <folly/Portability.h>
#include <folly/io/async/EventBase.h>
#include <gflags/gflags.h>
#include <iostream>
#include <thread>
#include <folly/io/async/AsyncSSLSocket.h>
#include <folly/io/async/AsyncSocket.h>
#include <vector>
using namespace std;
using namespace folly;
DEFINE_int32(clients, 1, "Number of simulated SSL clients");
DEFINE_int32(threads, 1, "Number of threads to spread clients across");
DEFINE_int32(requests, 2, "Total number of requests per client");
DEFINE_int32(port, 9423, "Server port");
DEFINE_bool(sticky, false, "A given client sends all reqs to one "
"(random) server");
DEFINE_bool(global, false, "All clients in a thread use the same SSL session");
DEFINE_bool(handshakes, false, "Force 100% handshakes");
string f_servers[10];
int f_num_servers = 0;
int tnum = 0;
class ClientRunner {
public:
ClientRunner(): reqs(0), hits(0), miss(0), num(tnum++) {}
void run();
int reqs;
int hits;
int miss;
int num;
};
class SSLCacheClient : public AsyncSocket::ConnectCallback,
public AsyncSSLSocket::HandshakeCB
{
private:
EventBase* eventBase_;
int currReq_;
int serverIdx_;
AsyncSocket* socket_;
AsyncSSLSocket* sslSocket_;
SSL_SESSION* session_;
SSL_SESSION **pSess_;
std::shared_ptr<SSLContext> ctx_;
ClientRunner* cr_;
public:
SSLCacheClient(EventBase* eventBase, SSL_SESSION **pSess, ClientRunner* cr);
~SSLCacheClient() {
if (session_ && !FLAGS_global)
SSL_SESSION_free(session_);
if (socket_ != nullptr) {
if (sslSocket_ != nullptr) {
sslSocket_->destroy();
sslSocket_ = nullptr;
}
socket_->destroy();
socket_ = nullptr;
}
};
void start();
virtual void connectSuccess() noexcept;
virtual void connectErr(const AsyncSocketException& ex)
noexcept ;
virtual void handshakeSuc(AsyncSSLSocket* sock) noexcept;
virtual void handshakeErr(
AsyncSSLSocket* sock,
const AsyncSocketException& ex) noexcept;
};
int
main(int argc, char* argv[])
{
gflags::SetUsageMessage(std::string("\n\n"
"usage: sslcachetest [options] -c <clients> -t <threads> servers\n"
));
gflags::ParseCommandLineFlags(&argc, &argv, true);
int reqs = 0;
int hits = 0;
int miss = 0;
struct timeval start;
struct timeval end;
struct timeval result;
srand((unsigned int)time(nullptr));
for (int i = 1; i < argc; i++) {
f_servers[f_num_servers++] = argv[i];
}
if (f_num_servers == 0) {
cout << "require at least one server\n";
return 1;
}
gettimeofday(&start, nullptr);
if (FLAGS_threads == 1) {
ClientRunner r;
r.run();
gettimeofday(&end, nullptr);
reqs = r.reqs;
hits = r.hits;
miss = r.miss;
}
else {
std::vector<ClientRunner> clients;
std::vector<std::thread> threads;
for (int t = 0; t < FLAGS_threads; t++) {
threads.emplace_back([&] {
clients[t].run();
});
}
for (auto& thr: threads) {
thr.join();
}
gettimeofday(&end, nullptr);
for (const auto& client: clients) {
reqs += client.reqs;
hits += client.hits;
miss += client.miss;
}
}
timersub(&end, &start, &result);
cout << "Requests: " << reqs << endl;
cout << "Handshakes: " << miss << endl;
cout << "Resumes: " << hits << endl;
cout << "Runtime(ms): " << result.tv_sec << "." << result.tv_usec / 1000 <<
endl;
cout << "ops/sec: " << (reqs * 1.0) /
((double)result.tv_sec * 1.0 + (double)result.tv_usec / 1000000.0) << endl;
return 0;
}
void
ClientRunner::run()
{
EventBase eb;
std::list<SSLCacheClient *> clients;
SSL_SESSION* session = nullptr;
for (int i = 0; i < FLAGS_clients; i++) {
SSLCacheClient* c = new SSLCacheClient(&eb, &session, this);
c->start();
clients.push_back(c);
}
eb.loop();
for (auto it = clients.begin(); it != clients.end(); it++) {
delete* it;
}
reqs += hits + miss;
}
SSLCacheClient::SSLCacheClient(EventBase* eb,
SSL_SESSION **pSess,
ClientRunner* cr)
: eventBase_(eb),
currReq_(0),
serverIdx_(0),
socket_(nullptr),
sslSocket_(nullptr),
session_(nullptr),
pSess_(pSess),
cr_(cr)
{
ctx_.reset(new SSLContext());
ctx_->setOptions(SSL_OP_NO_TICKET);
}
void
SSLCacheClient::start()
{
if (currReq_ >= FLAGS_requests) {
cout << "+";
return;
}
if (currReq_ == 0 || !FLAGS_sticky) {
serverIdx_ = rand() % f_num_servers;
}
if (socket_ != nullptr) {
if (sslSocket_ != nullptr) {
sslSocket_->destroy();
sslSocket_ = nullptr;
}
socket_->destroy();
socket_ = nullptr;
}
socket_ = new AsyncSocket(eventBase_);
socket_->connect(this, f_servers[serverIdx_], (uint16_t)FLAGS_port);
}
void
SSLCacheClient::connectSuccess() noexcept
{
sslSocket_ = new AsyncSSLSocket(ctx_, eventBase_, socket_->detachFd(),
false);
if (!FLAGS_handshakes) {
if (session_ != nullptr)
sslSocket_->setSSLSession(session_);
else if (FLAGS_global && pSess_ != nullptr)
sslSocket_->setSSLSession(*pSess_);
}
sslSocket_->sslConn(this);
}
void
SSLCacheClient::connectErr(const AsyncSocketException& ex)
noexcept
{
cout << "connectError: " << ex.what() << endl;
}
void
SSLCacheClient::handshakeSuc(AsyncSSLSocket* socket) noexcept
{
if (sslSocket_->getSSLSessionReused()) {
cr_->hits++;
} else {
cr_->miss++;
if (session_ != nullptr) {
SSL_SESSION_free(session_);
}
session_ = sslSocket_->getSSLSession();
if (FLAGS_global && pSess_ != nullptr && *pSess_ == nullptr) {
*pSess_ = session_;
}
}
if ( ((cr_->hits + cr_->miss) % 100) == ((100 / FLAGS_threads) * cr_->num)) {
cout << ".";
cout.flush();
}
sslSocket_->closeNow();
currReq_++;
this->start();
}
void
SSLCacheClient::handshakeErr(
AsyncSSLSocket* sock,
const AsyncSocketException& ex)
noexcept
{
cout << "handshakeError: " << ex.what() << endl;
}
folly/wangle/ssl/test/SSLContextManagerTest.cpp deleted 100644 → 0
View file @ a716b86b
/*
* Copyright (c) 2015, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
*/
#include <folly/io/async/EventBase.h>
#include <folly/io/async/SSLContext.h>
#include <glog/logging.h>
#include <gtest/gtest.h>
#include <folly/wangle/ssl/SSLContextManager.h>
#include <folly/wangle/acceptor/DomainNameMisc.h>
using std::shared_ptr;
namespace folly {
TEST(SSLContextManagerTest, Test1)
{
EventBase eventBase;
SSLContextManager 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>();
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);
try {
sslCtxMgr.insertSSLCtxByDomainName(
"www.facebook.com",
strlen("www.facebook.com"),
std::make_shared<SSLContext>());
} catch (const std::exception& ex) {
}
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);
try {
sslCtxMgr.insertSSLCtxByDomainName(
"*.abc.facebook.com",
strlen("*.abc.facebook.com"),
std::make_shared<SSLContext>());
FAIL();
} catch (const std::exception& ex) {
}
shared_ptr<SSLContext> retCtx;
retCtx = sslCtxMgr.getSSLCtx(DNString("www.facebook.com"));
EXPECT_EQ(retCtx, www_facebook_com_ctx);
retCtx = sslCtxMgr.getSSLCtx(DNString("WWW.facebook.com"));
EXPECT_EQ(retCtx, www_facebook_com_ctx);
EXPECT_FALSE(sslCtxMgr.getSSLCtx(DNString("xyz.facebook.com")));
retCtx = sslCtxMgr.getSSLCtxBySuffix(DNString("xyz.facebook.com"));
EXPECT_EQ(retCtx, start_facebook_com_ctx);
retCtx = sslCtxMgr.getSSLCtxBySuffix(DNString("XYZ.facebook.com"));
EXPECT_EQ(retCtx, start_facebook_com_ctx);
retCtx = sslCtxMgr.getSSLCtxBySuffix(DNString("www.abc.facebook.com"));
EXPECT_EQ(retCtx, start_abc_facebook_com_ctx);
// ensure "facebook.com" does not match "*.facebook.com"
EXPECT_FALSE(sslCtxMgr.getSSLCtxBySuffix(DNString("facebook.com")));
// ensure "Xfacebook.com" does not match "*.facebook.com"
EXPECT_FALSE(sslCtxMgr.getSSLCtxBySuffix(DNString("Xfacebook.com")));
// ensure wildcard name only matches one domain up
EXPECT_FALSE(sslCtxMgr.getSSLCtxBySuffix(DNString("abc.xyz.facebook.com")));
eventBase.loop(); // Clean up events before SSLContextManager is destructed
}
}
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment