rocksdb/thrift/lib/cpp/async/TEventWorker.h

265 lines
7.8 KiB
C
Raw Normal View History

// Copyright (c) 2006- Facebook
// Distributed under the Thrift Software License
//
// See accompanying file LICENSE or visit the Thrift site at:
// http://developers.facebook.com/thrift/
#ifndef THRIFT_SERVER_TEVENTWORKER_H_
#define THRIFT_SERVER_TEVENTWORKER_H_ 1
#include "thrift/lib/cpp/async/TAsyncServerSocket.h"
#include "thrift/lib/cpp/async/TAsyncSSLSocket.h"
#include "thrift/lib/cpp/async/TEventServer.h"
#include "thrift/lib/cpp/async/TEventBase.h"
#include "thrift/lib/cpp/async/TEventHandler.h"
#include "thrift/lib/cpp/async/TNotificationQueue.h"
#include "thrift/lib/cpp/server/TServer.h"
#include <ext/hash_map>
#include <list>
#include <stack>
namespace apache { namespace thrift { namespace async {
// Forward declaration of classes
class TAsyncProcessorFactory;
class TEventConnection;
class TEventServer;
class TaskCompletionMessage;
/**
* TEventWorker drives the actual I/O for TEventServer connections.
*
* The TEventServer itself accepts incoming connections, then hands off each
* connection to a TEventWorker running in another thread. There should
* typically be around one TEventWorker thread per core.
*/
class TEventWorker :
public apache::thrift::server::TServer,
public TAsyncServerSocket::AcceptCallback,
public TAsyncSSLSocket::HandshakeCallback,
public TNotificationQueue<TaskCompletionMessage>::Consumer {
private:
/// Object that processes requests.
boost::shared_ptr<TAsyncProcessorFactory> asyncProcessorFactory_;
/// The mother ship.
TEventServer* server_;
/// An instance's TEventBase for I/O.
TEventBase eventBase_;
/// Our ID in [0:nWorkers).
uint32_t workerID_;
/// Pipe that task completion notifications are sent over
TNotificationQueue<TaskCompletionMessage> notificationQueue_;
/**
* A stack of idle TEventConnection objects for reuse.
* When we close a connection, we place it on this stack so that the
* object can be reused later, rather than freeing the memory and
* reallocating a new object later.
*/
std::stack<TEventConnection*> connectionStack_;
/// Transport type to use
TEventServer::TransportType transportType_;
/**
* Called when the connection is fully accepted (after SSL accept if needed)
*/
void finishConnectionAccepted(TAsyncSocket *asyncSock);
/**
* Create or reuse a TEventConnection initialized for the given socket FD.
*
* @param socket the FD of a freshly-connected socket.
* @param address the peer address of the socket.
* @return pointer to a TConenction object for that socket.
*/
TEventConnection* createConnection(
boost::shared_ptr<TAsyncSocket> asyncSocket,
const transport::TSocketAddress* address);
/**
* Handler called when a new connection may be available.
*/
void acceptConnections();
void makeCompletionCallback();
/**
* Initialize our TEventBase to generate incoming connection events.
* Note that this is called once before the main loop is executed and
* sets up a READ event on the output of the listener's socktpair.
*/
void registerEvents();
/**
* Callback used when loop latency exceeds the requested threshold.
*/
void maxLatencyCob();
typedef std::list<TEventConnection*> ConnectionList;
// pointer hash functor
static const uint64_t kPtrHashMult = 5700357409661599291LL;
static const uint64_t kPtrHashShift = 3;
template<typename T>
struct hash { };
template<typename T>
struct hash<T*> {
size_t operator()(T* p) const {
return ((size_t)p ^ ((size_t)p >> kPtrHashShift)) * kPtrHashMult;
}
size_t operator()(const T* p) const {
return ((size_t)p ^ ((size_t)p >> kPtrHashShift)) * kPtrHashMult;
}
};
typedef __gnu_cxx::hash_map<const TEventConnection*,
ConnectionList::iterator,
hash<TEventConnection*> > ConnectionMap;
/**
* The list of active connections (used to allow the oldest connections
* to be shed during overload).
*/
ConnectionList activeConnectionList_;
/**
* A hash map used to map connections to their place in the connection list
*/
ConnectionMap activeConnectionMap_;
public:
/**
* TEventWorker is the actual server object for existing connections.
* One or more of these should be created by TEventServer (one per
* CPU core is recommended).
*
* @param processorFactory a TAsyncProcessorFactory object as
* obtained from the generated Thrift code (the user service
* is integrated through this).
* @param inputProtocolFactory the TProtocolFactory class supporting
* inbound Thrift requests.
* @param outputProtocolFactory the TProtocolFactory class supporting
* responses (if any) after processing completes.
* @param server the TEventServer which created us.
* @param workerID the ID assigned to this worker
*/
TEventWorker(boost::shared_ptr<TAsyncProcessorFactory> processorFactory,
boost::shared_ptr<apache::thrift::server::TDuplexProtocolFactory>
protocolFactory,
TEventServer* server,
uint32_t workerID) :
TServer(boost::shared_ptr<apache::thrift::server::TProcessor>()),
asyncProcessorFactory_(processorFactory),
server_(server),
eventBase_(),
workerID_(workerID),
transportType_(TEventServer::FRAMED) {
setDuplexProtocolFactory(protocolFactory);
transportType_ = server->getTransportType();
if (transportType_ == TEventServer::FRAMED) {
// do the dynamic cast once rather than per connection
if (dynamic_cast<apache::thrift::protocol::THeaderProtocolFactory*>(
protocolFactory.get())) {
transportType_ = TEventServer::HEADER;
}
}
}
/**
* Destroy a TEventWorker. We've use boost::scoped_ptr<> to take care
* of freeing up memory, so nothing to be done here but release the
* connection stack.
*/
virtual ~TEventWorker();
/**
* Get my TAsyncProcessorFactory object.
*
* @returns pointer to my TAsyncProcessorFactory object.
*/
boost::shared_ptr<TAsyncProcessorFactory> getAsyncProcessorFactory() {
return asyncProcessorFactory_;
}
/**
* Get my TEventBase object.
*
* @returns pointer to my TEventBase object.
*/
TEventBase* getEventBase() {
return &eventBase_;
}
/**
* Get underlying server.
*
* @returns pointer to TEventServer
*/
TEventServer* getServer() const {
return server_;
}
/**
* Get my numeric worker ID (for diagnostics).
*
* @return integer ID of this worker
*/
int32_t getID() {
return workerID_;
}
/**
* Dispose of a TEventConnection object.
* Will add to a pool of these objects or destroy as necessary.
*
* @param connection a now-idle connection.
*/
void returnConnection(TEventConnection* connection);
/**
* Cause a completion callback for the requested connection to occur
* within that connection's context.
*
* @param msg task completion message
* @return true if notification was sent, false if it failed.
*/
bool notifyCompletion(TaskCompletionMessage &&msg);
/**
* Task completed (called in this worker's thread)
*/
void messageAvailable(TaskCompletionMessage &&msg);
virtual void connectionAccepted(int fd,
const transport::TSocketAddress& clientAddr)
THRIFT_NOEXCEPT;
virtual void acceptError(const std::exception& ex) THRIFT_NOEXCEPT;
virtual void acceptStopped() THRIFT_NOEXCEPT;
/**
* TAsyncSSLSocket::HandshakeCallback interface
*/
void handshakeSuccess(TAsyncSSLSocket *sock) THRIFT_NOEXCEPT;
void handshakeError(TAsyncSSLSocket *sock,
const transport::TTransportException& ex) THRIFT_NOEXCEPT;
/**
* Enter event loop and serve.
*/
void serve();
/**
* Exit event loop.
*/
void shutdown();
};
}}} // apache::thrift::async
#endif // #ifndef THRIFT_SERVER_TEVENTWORKER_H_