2012-07-03 07:45:59 +02:00
|
|
|
/*
|
|
|
|
* Licensed to the Apache Software Foundation (ASF) under one
|
|
|
|
* or more contributor license agreements. See the NOTICE file
|
|
|
|
* distributed with this work for additional information
|
|
|
|
* regarding copyright ownership. The ASF licenses this file
|
|
|
|
* to you 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.
|
|
|
|
*/
|
|
|
|
#ifndef THRIFT_ASYNC_TEVENTSERVER_H_
|
|
|
|
#define THRIFT_ASYNC_TEVENTSERVER_H_ 1
|
|
|
|
|
|
|
|
#include "thrift/lib/cpp/Thrift.h"
|
|
|
|
#include "thrift/lib/cpp/server/TServer.h"
|
|
|
|
#include "thrift/lib/cpp/async/TAsyncProcessor.h"
|
|
|
|
#include "thrift/lib/cpp/transport/TTransportUtils.h"
|
|
|
|
#include "thrift/lib/cpp/transport/TSSLSocket.h"
|
|
|
|
#include "thrift/lib/cpp/protocol/THeaderProtocol.h"
|
|
|
|
#include "thrift/lib/cpp/concurrency/Mutex.h"
|
|
|
|
#include "thrift/lib/cpp/concurrency/ThreadLocal.h"
|
|
|
|
#include "thrift/lib/cpp/async/TEventBase.h"
|
|
|
|
#include "thrift/lib/cpp/async/TEventBaseManager.h"
|
|
|
|
#include <vector>
|
|
|
|
#include <map>
|
|
|
|
#include <cstdlib>
|
|
|
|
#include <boost/scoped_ptr.hpp>
|
|
|
|
|
|
|
|
namespace apache { namespace thrift {
|
|
|
|
|
|
|
|
namespace concurrency {
|
|
|
|
class ThreadFactory;
|
|
|
|
class ThreadManager;
|
|
|
|
}
|
|
|
|
|
|
|
|
namespace async {
|
|
|
|
|
|
|
|
using apache::thrift::protocol::TDualProtocolFactory;
|
|
|
|
|
|
|
|
// Forward declaration of classes
|
|
|
|
class TAsyncServerSocket;
|
|
|
|
class TEventConnection;
|
|
|
|
class TEventWorker;
|
|
|
|
|
|
|
|
/**
|
|
|
|
This is a non-blocking event-based server for high performance that
|
|
|
|
operates an I/O thread for each cpu core and uses callbacks for
|
|
|
|
notification of processing or I/O operations.
|
|
|
|
|
|
|
|
It does not use the TServerTransport framework, but rather has socket
|
|
|
|
operations hardcoded for use with libevent and implements framing
|
|
|
|
compatible with TFramedTransport. A single "listener" thread accepts
|
|
|
|
connections and sends them to the server threads via a single socketpair();
|
|
|
|
the server threads are each responsible for allocating and pooling actual
|
|
|
|
connection objects, avoiding the need for the locks required by a common
|
|
|
|
pool.
|
|
|
|
|
|
|
|
The original Thrift server was by Mark Slee <mcslee@facebook.com>.
|
|
|
|
A non-blocking variant was produced which allowed for a large number
|
|
|
|
of processing threads but restricted network I/O to a single thread --
|
|
|
|
suboptimal on a multi-core CPU. David Reiss <dreiss@facebook.com>
|
|
|
|
and Mark Rabkin <mrabkin@facebook.com> refactored this server into a
|
|
|
|
callback-driven event-based configuration. Ed Hall <edhall@facebook.com>
|
|
|
|
elaborated on this to support network I/O on multiple threads (ideally
|
|
|
|
one per CPU core).
|
|
|
|
|
|
|
|
@author Mark Slee <mcslee@facebook.com>
|
|
|
|
@author David Reiss <dreiss@facebook.com>
|
|
|
|
@author Mark Rabkin <mrabkin@facebook.com>
|
|
|
|
@author Ed Hall <edhall@facebook.com>
|
|
|
|
*/
|
|
|
|
|
|
|
|
class TEventServer : public apache::thrift::server::TServer {
|
|
|
|
|
|
|
|
public:
|
|
|
|
enum TransportType {
|
|
|
|
FRAMED = 0,
|
|
|
|
HEADER = 1,
|
|
|
|
|
|
|
|
/*********** Deprecation Warning *******************
|
|
|
|
* *
|
|
|
|
* The unframed transports are deprecated ! *
|
|
|
|
* They should be used for legancy services only *
|
|
|
|
* Also note: they only works with TBinaryProtocol *
|
|
|
|
***************************************************/
|
|
|
|
|
|
|
|
UNFRAMED_BINARY = 2
|
|
|
|
};
|
|
|
|
|
|
|
|
protected:
|
|
|
|
//! Default max size of per-worker connection pool.
|
|
|
|
static const uint32_t T_ASYNC_MAX_CONNECTION_POOL_SIZE = 64;
|
|
|
|
|
|
|
|
/// Starting size of a TEventConnection's read buffer
|
|
|
|
static const int T_ASYNC_READ_BUFFER_DEFAULT_SIZE = 1024;
|
|
|
|
|
|
|
|
/// Starting size of a TEventConnection's write buffer
|
|
|
|
static const int T_ASYNC_WRITE_BUFFER_DEFAULT_SIZE = 1024;
|
|
|
|
|
|
|
|
/// Maximum size of read buffer allocated to idle connection (0 = unlimited)
|
|
|
|
static const int T_ASYNC_IDLE_READ_BUFFER_LIMIT = 0;
|
|
|
|
|
|
|
|
/// Maximum size of write buffer allocated to idle connection (0 = unlimited)
|
|
|
|
static const int T_ASYNC_IDLE_WRITE_BUFFER_LIMIT = 0;
|
|
|
|
|
|
|
|
/// # of calls before resizing oversized buffers (0 = check only on close)
|
|
|
|
static const int T_ASYNC_RESIZE_BUFFER_EVERY_N = 0;
|
|
|
|
|
|
|
|
//! Default number of worker threads (should be # of processor cores).
|
|
|
|
static const int T_ASYNC_DEFAULT_WORKER_THREADS = 4;
|
|
|
|
|
|
|
|
//! Maximum size of a frame we'll accept (default = 64MB)
|
|
|
|
static const int T_ASYNC_DEFAULT_MAX_FRAME_SIZE = 67108864;
|
|
|
|
|
|
|
|
static const uint32_t T_MAX_NUM_MESSAGES_IN_PIPE = 0xffffffff;
|
|
|
|
|
|
|
|
/// Listen backlog
|
|
|
|
static const int T_LISTEN_BACKLOG = 1024;
|
|
|
|
|
|
|
|
//! Transport type
|
|
|
|
static const TransportType T_ASYNC_DEFAULT_TRANSPORT_TYPE = FRAMED;
|
|
|
|
|
|
|
|
private:
|
|
|
|
struct WorkerInfo {
|
|
|
|
boost::shared_ptr<TEventWorker> worker;
|
|
|
|
boost::shared_ptr<apache::thrift::concurrency::Thread> thread;
|
|
|
|
};
|
|
|
|
|
|
|
|
//! Max size of per-worker connection pool (may be set).
|
|
|
|
uint32_t maxConnectionPoolSize_;
|
|
|
|
|
|
|
|
//! SSL context
|
|
|
|
boost::shared_ptr<transport::SSLContext> sslContext_;
|
|
|
|
|
|
|
|
//! Factory that creates connection processor objects.
|
|
|
|
boost::shared_ptr<TAsyncProcessorFactory> asyncProcessorFactory_;
|
|
|
|
|
|
|
|
//! Port to listen on
|
|
|
|
uint16_t port_;
|
|
|
|
|
|
|
|
//! Listen socket
|
|
|
|
TAsyncServerSocket* socket_;
|
|
|
|
|
|
|
|
//! The TEventBase currently driving serve(). NULL when not serving.
|
|
|
|
TEventBase* serveEventBase_;
|
|
|
|
|
|
|
|
//! Number of worker threads (may be set) (should be # of CPU cores)
|
|
|
|
int nWorkers_;
|
|
|
|
|
|
|
|
//! Milliseconds we'll wait for data to appear (0 = infinity)
|
|
|
|
int timeout_;
|
|
|
|
|
|
|
|
//! Manager of per-thread TEventBase objects.
|
|
|
|
TEventBaseManager eventBaseManager_;
|
|
|
|
|
|
|
|
//! Last worker chosen -- used to select workers in round-robin sequence.
|
|
|
|
uint32_t workerChoice_;
|
|
|
|
|
|
|
|
//! List of workers.
|
|
|
|
typedef std::vector<WorkerInfo> WorkerVector;
|
|
|
|
WorkerVector workers_;
|
|
|
|
|
|
|
|
//! Maximum number of bytes accepted in a frame.
|
|
|
|
uint32_t maxFrameSize_;
|
|
|
|
|
|
|
|
/// We initialize (and reinitialize) TEventConnection's read buffer to
|
|
|
|
/// this size.
|
|
|
|
size_t readBufferDefaultSize_;
|
|
|
|
|
|
|
|
/// We initialize (and reinitialize) TEventConnection's write buffer to
|
|
|
|
/// this size.
|
|
|
|
size_t writeBufferDefaultSize_;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Max read buffer size for an idle TConnection. When we place an idle
|
|
|
|
* TConnection into TEventWorker::connectionStack_ or on every
|
|
|
|
* resizeBufferEveryN_ calls, we insure that its read buffer is <= to
|
|
|
|
* this size; otherwise we replace it with a new one to insure that idle
|
|
|
|
* connections don't hog memory. 0 disables this check.
|
|
|
|
*/
|
|
|
|
size_t idleReadBufferLimit_;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Max write buffer size for an idle connection. When we place an idle
|
|
|
|
* TConnection into TEventWorker::connectionStack_ or on every
|
|
|
|
* resizeBufferEveryN_ calls, we insure that its write buffer is <= to
|
|
|
|
* this size; otherwise we replace it with a new one to insure that idle
|
|
|
|
* connections don't hog memory. 0 disables this check.
|
|
|
|
*/
|
|
|
|
size_t idleWriteBufferLimit_;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Every N calls we check the buffer size limits on a connected
|
|
|
|
* TEventConnection. 0 disables (i.e. the checks are only done when a
|
|
|
|
* connection closes).
|
|
|
|
*/
|
|
|
|
int32_t resizeBufferEveryN_;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Call timeout in ms. When nonzero, limits the amount of time we allow
|
|
|
|
* between the start of a call and the actual invokation of its processor.
|
|
|
|
* The connection closes if it is exceeded.
|
|
|
|
*/
|
|
|
|
int32_t callTimeout_;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* The thread manager used when we're in queuing mode.
|
|
|
|
*/
|
|
|
|
boost::shared_ptr<concurrency::ThreadManager> threadManager_;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Thread local storage to track the current connection being processed
|
|
|
|
*/
|
|
|
|
concurrency::ThreadLocal<TEventConnection,
|
|
|
|
concurrency::NoopThreadLocalManager<TEventConnection> >
|
|
|
|
currentConnection_;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* The time in milliseconds before an unperformed task expires --
|
|
|
|
* queuing mode only. (0 == infinite)
|
|
|
|
*/
|
|
|
|
uint64_t taskExpireTime_;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Set true if we are in queuing mode, false if not.
|
|
|
|
*/
|
|
|
|
bool queuingMode_;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* The speed for adjusting connection accept rate.
|
|
|
|
* 0 for disabling auto adjusting connection accept rate.
|
|
|
|
*/
|
|
|
|
double acceptRateAdjustSpeed_;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* The maximum number of unprocessed messages which a NotificationPipe
|
|
|
|
* can hold.
|
|
|
|
*/
|
|
|
|
uint32_t maxNumMsgsInPipe_;
|
|
|
|
|
2012-07-10 19:19:49 +02:00
|
|
|
/**
|
|
|
|
* The max number of active connections for each worker
|
|
|
|
*/
|
|
|
|
int32_t maxNumActiveConnectionsPerWorker_;
|
|
|
|
|
2012-07-03 07:45:59 +02:00
|
|
|
/**
|
|
|
|
* The transport type to use
|
|
|
|
*/
|
|
|
|
TransportType transportType_;
|
|
|
|
|
|
|
|
void addWorker(concurrency::ThreadFactory* threadFactory);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* No-op signal handler (for SIGPIPE)
|
|
|
|
*/
|
|
|
|
static void sigNoOp(int signo) {
|
|
|
|
(void)signo;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Set the current connection
|
|
|
|
*/
|
|
|
|
void setCurrentConnection(TEventConnection* conn) {
|
|
|
|
assert(currentConnection_.get() == NULL);
|
|
|
|
currentConnection_.set(conn);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Clear the current connection
|
|
|
|
*/
|
|
|
|
void clearCurrentConnection() {
|
|
|
|
currentConnection_.clear();
|
|
|
|
}
|
|
|
|
// Allow TEventConnection and TEventTask to access setCurrentConnection()
|
|
|
|
// and clearCurrentConnection(). Only these two private
|
|
|
|
// methods are meant to be used by TEventConnection and TEventTask.
|
|
|
|
friend class TEventConnection;
|
|
|
|
friend class TEventTask;
|
|
|
|
|
|
|
|
public:
|
|
|
|
/** Construct an async Thrift server.
|
|
|
|
You need to compile your thrift configuration with thrift_cpp_options =
|
|
|
|
"cob_style" to get the required TAsyncProcessor class; this differs
|
|
|
|
from the usual TProcessor object by adding a completion callback.
|
|
|
|
TBinaryProtocol is assumed for both input and output with this
|
|
|
|
constructor.
|
|
|
|
@param processor the TAsyncProcessor object for this service
|
|
|
|
@param port the TCP port number for this service
|
|
|
|
@param nWorkers the number of worker threads -- should be the same
|
|
|
|
as the number of CPU cores, though if a process has
|
|
|
|
more than one TEventServer the cores can be split
|
|
|
|
between them.
|
|
|
|
*/
|
|
|
|
template<typename AsyncProcessor>
|
|
|
|
TEventServer(boost::shared_ptr<AsyncProcessor> processor,
|
|
|
|
int port,
|
|
|
|
int nWorkers = T_ASYNC_DEFAULT_WORKER_THREADS,
|
|
|
|
THRIFT_OVERLOAD_IF(AsyncProcessor, TAsyncProcessor)) :
|
|
|
|
apache::thrift::server::TServer(boost::shared_ptr<TProcessor>()),
|
|
|
|
maxConnectionPoolSize_(T_ASYNC_MAX_CONNECTION_POOL_SIZE),
|
|
|
|
asyncProcessorFactory_(new TAsyncSingletonProcessorFactory(processor)),
|
|
|
|
port_(port),
|
|
|
|
socket_(NULL),
|
|
|
|
serveEventBase_(NULL),
|
|
|
|
nWorkers_(nWorkers),
|
|
|
|
timeout_(0),
|
|
|
|
eventBaseManager_(),
|
|
|
|
workerChoice_(0),
|
|
|
|
maxFrameSize_(T_ASYNC_DEFAULT_MAX_FRAME_SIZE),
|
|
|
|
readBufferDefaultSize_(T_ASYNC_READ_BUFFER_DEFAULT_SIZE),
|
|
|
|
writeBufferDefaultSize_(T_ASYNC_WRITE_BUFFER_DEFAULT_SIZE),
|
|
|
|
idleReadBufferLimit_(T_ASYNC_IDLE_READ_BUFFER_LIMIT),
|
|
|
|
idleWriteBufferLimit_(T_ASYNC_IDLE_WRITE_BUFFER_LIMIT),
|
|
|
|
resizeBufferEveryN_(T_ASYNC_RESIZE_BUFFER_EVERY_N),
|
|
|
|
callTimeout_(0),
|
|
|
|
taskExpireTime_(0),
|
|
|
|
queuingMode_(false),
|
|
|
|
acceptRateAdjustSpeed_(0),
|
|
|
|
maxNumMsgsInPipe_(T_MAX_NUM_MESSAGES_IN_PIPE),
|
2012-07-10 19:19:49 +02:00
|
|
|
maxNumActiveConnectionsPerWorker_(0),
|
2012-07-03 07:45:59 +02:00
|
|
|
transportType_(T_ASYNC_DEFAULT_TRANSPORT_TYPE) {
|
|
|
|
processor->setAsyncServer(this);
|
|
|
|
}
|
|
|
|
|
|
|
|
/** Construct an async Thrift server for a particular TProtocol.
|
|
|
|
See above; adds a "protocolFactory" parameter to replace the
|
|
|
|
default TBinaryProtocol.
|
|
|
|
@param processor the TAsyncProcessor object for this service
|
|
|
|
@param protocolFactory the TProtocolFactory to use for input & output
|
|
|
|
@param port the TCP port number for this service
|
|
|
|
@param nWorkers the number of worker threads
|
|
|
|
*/
|
|
|
|
template<typename AsyncProcessor>
|
|
|
|
TEventServer(boost::shared_ptr<AsyncProcessor> processor,
|
|
|
|
boost::shared_ptr<apache::thrift::server::TProtocolFactory>
|
|
|
|
protocolFactory,
|
|
|
|
int port,
|
|
|
|
int nWorkers = T_ASYNC_DEFAULT_WORKER_THREADS,
|
|
|
|
THRIFT_OVERLOAD_IF(AsyncProcessor, TAsyncProcessor)) :
|
|
|
|
apache::thrift::server::TServer(boost::shared_ptr<TProcessor>()),
|
|
|
|
maxConnectionPoolSize_(T_ASYNC_MAX_CONNECTION_POOL_SIZE),
|
|
|
|
asyncProcessorFactory_(new TAsyncSingletonProcessorFactory(processor)),
|
|
|
|
port_(port),
|
|
|
|
socket_(NULL),
|
|
|
|
serveEventBase_(NULL),
|
|
|
|
nWorkers_(nWorkers),
|
|
|
|
timeout_(0),
|
|
|
|
eventBaseManager_(),
|
|
|
|
workerChoice_(0),
|
|
|
|
maxFrameSize_(T_ASYNC_DEFAULT_MAX_FRAME_SIZE),
|
|
|
|
readBufferDefaultSize_(T_ASYNC_READ_BUFFER_DEFAULT_SIZE),
|
|
|
|
writeBufferDefaultSize_(T_ASYNC_WRITE_BUFFER_DEFAULT_SIZE),
|
|
|
|
idleReadBufferLimit_(T_ASYNC_IDLE_READ_BUFFER_LIMIT),
|
|
|
|
idleWriteBufferLimit_(T_ASYNC_IDLE_WRITE_BUFFER_LIMIT),
|
|
|
|
resizeBufferEveryN_(T_ASYNC_RESIZE_BUFFER_EVERY_N),
|
|
|
|
callTimeout_(0),
|
|
|
|
taskExpireTime_(0),
|
|
|
|
queuingMode_(false),
|
|
|
|
acceptRateAdjustSpeed_(0),
|
|
|
|
maxNumMsgsInPipe_(T_MAX_NUM_MESSAGES_IN_PIPE),
|
2012-07-10 19:19:49 +02:00
|
|
|
maxNumActiveConnectionsPerWorker_(0),
|
2012-07-03 07:45:59 +02:00
|
|
|
transportType_(T_ASYNC_DEFAULT_TRANSPORT_TYPE) {
|
|
|
|
processor->setAsyncServer(this);
|
|
|
|
|
|
|
|
setProtocolFactory(protocolFactory);
|
|
|
|
}
|
|
|
|
|
|
|
|
/** Construct an async Thrift server with different input & output TProtocol.
|
|
|
|
See above; adds "inputProtocolFactory" and "outputProtocolFactory"
|
|
|
|
parameters.
|
|
|
|
@param processor the TAsyncProcessor object for this service
|
|
|
|
@param inputProtocolFactory the TProtocolFactory to use for input
|
|
|
|
@param outputProtocolFactory the TProtocolFactory to use for output
|
|
|
|
@param port the TCP port number for this service
|
|
|
|
@param nWorkers the number of worker threads
|
|
|
|
|
|
|
|
@deprecated use TDuplex* ctor below
|
|
|
|
*/
|
|
|
|
template<typename AsyncProcessor>
|
|
|
|
TEventServer(boost::shared_ptr<AsyncProcessor> processor,
|
|
|
|
boost::shared_ptr<apache::thrift::server::TProtocolFactory>
|
|
|
|
inputProtocolFactory,
|
|
|
|
boost::shared_ptr<apache::thrift::server::TProtocolFactory>
|
|
|
|
outputProtocolFactory,
|
|
|
|
int port,
|
|
|
|
int nWorkers = T_ASYNC_DEFAULT_WORKER_THREADS,
|
|
|
|
THRIFT_OVERLOAD_IF(AsyncProcessor, TAsyncProcessor)) :
|
|
|
|
apache::thrift::server::TServer(boost::shared_ptr<TProcessor>()),
|
|
|
|
maxConnectionPoolSize_(T_ASYNC_MAX_CONNECTION_POOL_SIZE),
|
|
|
|
asyncProcessorFactory_(new TAsyncSingletonProcessorFactory(processor)),
|
|
|
|
port_(port),
|
|
|
|
socket_(NULL),
|
|
|
|
serveEventBase_(NULL),
|
|
|
|
nWorkers_(nWorkers),
|
|
|
|
timeout_(0),
|
|
|
|
eventBaseManager_(),
|
|
|
|
workerChoice_(0),
|
|
|
|
maxFrameSize_(T_ASYNC_DEFAULT_MAX_FRAME_SIZE),
|
|
|
|
readBufferDefaultSize_(T_ASYNC_READ_BUFFER_DEFAULT_SIZE),
|
|
|
|
writeBufferDefaultSize_(T_ASYNC_WRITE_BUFFER_DEFAULT_SIZE),
|
|
|
|
idleReadBufferLimit_(T_ASYNC_IDLE_READ_BUFFER_LIMIT),
|
|
|
|
idleWriteBufferLimit_(T_ASYNC_IDLE_WRITE_BUFFER_LIMIT),
|
|
|
|
resizeBufferEveryN_(T_ASYNC_RESIZE_BUFFER_EVERY_N),
|
|
|
|
callTimeout_(0),
|
|
|
|
taskExpireTime_(0),
|
|
|
|
queuingMode_(false),
|
|
|
|
acceptRateAdjustSpeed_(0),
|
|
|
|
maxNumMsgsInPipe_(T_MAX_NUM_MESSAGES_IN_PIPE),
|
2012-07-10 19:19:49 +02:00
|
|
|
maxNumActiveConnectionsPerWorker_(0),
|
2012-07-03 07:45:59 +02:00
|
|
|
transportType_(T_ASYNC_DEFAULT_TRANSPORT_TYPE) {
|
|
|
|
processor->setAsyncServer(this);
|
|
|
|
|
|
|
|
setDuplexProtocolFactory(
|
|
|
|
boost::shared_ptr<TDualProtocolFactory>(
|
|
|
|
new TDualProtocolFactory(inputProtocolFactory, outputProtocolFactory)));
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/** Construct an async Thrift server with custom input & output TProtocol.
|
|
|
|
See above; Replaces protocolFactory with duplexProtocolFactory
|
|
|
|
parameters.
|
|
|
|
@param processor the TAsyncProcessor object for this service
|
|
|
|
@param duplexProtocolFactory the TProtocolFactory to use for input/output
|
|
|
|
@param port the TCP port number for this service
|
|
|
|
@param nWorkers the number of worker threads
|
|
|
|
*/
|
|
|
|
template<typename AsyncProcessor>
|
|
|
|
TEventServer(boost::shared_ptr<AsyncProcessor> processor,
|
|
|
|
boost::shared_ptr<apache::thrift::server::TDuplexProtocolFactory>
|
|
|
|
duplexProtocolFactory,
|
|
|
|
int port,
|
|
|
|
int nWorkers = T_ASYNC_DEFAULT_WORKER_THREADS,
|
|
|
|
THRIFT_OVERLOAD_IF(AsyncProcessor, TAsyncProcessor)):
|
|
|
|
apache::thrift::server::TServer(boost::shared_ptr<TProcessor>()),
|
|
|
|
maxConnectionPoolSize_(T_ASYNC_MAX_CONNECTION_POOL_SIZE),
|
|
|
|
asyncProcessorFactory_(new TAsyncSingletonProcessorFactory(processor)),
|
|
|
|
port_(port),
|
|
|
|
socket_(NULL),
|
|
|
|
serveEventBase_(NULL),
|
|
|
|
nWorkers_(nWorkers),
|
|
|
|
timeout_(0),
|
|
|
|
eventBaseManager_(),
|
|
|
|
workerChoice_(0),
|
|
|
|
maxFrameSize_(T_ASYNC_DEFAULT_MAX_FRAME_SIZE),
|
|
|
|
readBufferDefaultSize_(T_ASYNC_READ_BUFFER_DEFAULT_SIZE),
|
|
|
|
writeBufferDefaultSize_(T_ASYNC_WRITE_BUFFER_DEFAULT_SIZE),
|
|
|
|
idleReadBufferLimit_(T_ASYNC_IDLE_READ_BUFFER_LIMIT),
|
|
|
|
idleWriteBufferLimit_(T_ASYNC_IDLE_WRITE_BUFFER_LIMIT),
|
|
|
|
resizeBufferEveryN_(T_ASYNC_RESIZE_BUFFER_EVERY_N),
|
|
|
|
callTimeout_(0),
|
|
|
|
taskExpireTime_(0),
|
|
|
|
queuingMode_(false),
|
|
|
|
acceptRateAdjustSpeed_(0),
|
|
|
|
maxNumMsgsInPipe_(T_MAX_NUM_MESSAGES_IN_PIPE),
|
2012-07-10 19:19:49 +02:00
|
|
|
maxNumActiveConnectionsPerWorker_(0),
|
2012-07-03 07:45:59 +02:00
|
|
|
transportType_(T_ASYNC_DEFAULT_TRANSPORT_TYPE) {
|
|
|
|
processor->setAsyncServer(this);
|
|
|
|
|
|
|
|
setDuplexProtocolFactory(duplexProtocolFactory);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/** Construct a task-queuing Thrift server for a particular TProtocol.
|
|
|
|
Largely compatible with TNonblockingServer.
|
|
|
|
|
|
|
|
@param processor the TProcessor object for this service
|
|
|
|
@param protocolFactory the TProtocolFactory to use for input & output
|
|
|
|
@param port the TCP port number for this service
|
|
|
|
@param threadManager the thread manager we use for task queuing
|
|
|
|
@param nWorkers the number of worker threads
|
|
|
|
*/
|
|
|
|
template<typename Processor>
|
|
|
|
TEventServer(
|
|
|
|
boost::shared_ptr<Processor>& processor,
|
|
|
|
boost::shared_ptr<apache::thrift::server::TProtocolFactory>&
|
|
|
|
protocolFactory,
|
|
|
|
int port,
|
|
|
|
boost::shared_ptr<concurrency::ThreadManager> const& threadManager =
|
|
|
|
boost::shared_ptr<concurrency::ThreadManager>(),
|
|
|
|
int nWorkers = T_ASYNC_DEFAULT_WORKER_THREADS,
|
|
|
|
THRIFT_OVERLOAD_IF(Processor, TProcessor)) :
|
|
|
|
apache::thrift::server::TServer(processor),
|
|
|
|
maxConnectionPoolSize_(T_ASYNC_MAX_CONNECTION_POOL_SIZE),
|
|
|
|
port_(port),
|
|
|
|
socket_(NULL),
|
|
|
|
serveEventBase_(NULL),
|
|
|
|
nWorkers_(nWorkers),
|
|
|
|
timeout_(0),
|
|
|
|
eventBaseManager_(),
|
|
|
|
workerChoice_(0),
|
|
|
|
maxFrameSize_(T_ASYNC_DEFAULT_MAX_FRAME_SIZE),
|
|
|
|
readBufferDefaultSize_(T_ASYNC_READ_BUFFER_DEFAULT_SIZE),
|
|
|
|
writeBufferDefaultSize_(T_ASYNC_WRITE_BUFFER_DEFAULT_SIZE),
|
|
|
|
idleReadBufferLimit_(T_ASYNC_IDLE_READ_BUFFER_LIMIT),
|
|
|
|
idleWriteBufferLimit_(T_ASYNC_IDLE_WRITE_BUFFER_LIMIT),
|
|
|
|
resizeBufferEveryN_(T_ASYNC_RESIZE_BUFFER_EVERY_N),
|
|
|
|
callTimeout_(0),
|
|
|
|
taskExpireTime_(0),
|
|
|
|
queuingMode_(true),
|
|
|
|
acceptRateAdjustSpeed_(0),
|
|
|
|
maxNumMsgsInPipe_(T_MAX_NUM_MESSAGES_IN_PIPE),
|
2012-07-10 19:19:49 +02:00
|
|
|
maxNumActiveConnectionsPerWorker_(0),
|
2012-07-03 07:45:59 +02:00
|
|
|
transportType_(T_ASYNC_DEFAULT_TRANSPORT_TYPE) {
|
|
|
|
setProtocolFactory(protocolFactory);
|
|
|
|
setThreadManager(threadManager);
|
|
|
|
}
|
|
|
|
|
|
|
|
/** Construct a task-queuing Thrift server for a particular TProtocol.
|
|
|
|
Largely compatible with TNonblockingServer.
|
|
|
|
|
|
|
|
@param processor the TProcessor object for this service
|
|
|
|
@param protocolFactory the TProtocolFactory to use for input & output
|
|
|
|
@param port the TCP port number for this service
|
|
|
|
@param threadManager the thread manager we use for task queuing
|
|
|
|
@param nWorkers the number of worker threads
|
|
|
|
*/
|
|
|
|
template<typename Processor>
|
|
|
|
TEventServer(
|
|
|
|
boost::shared_ptr<Processor>& processor,
|
|
|
|
boost::shared_ptr<apache::thrift::server::TDuplexProtocolFactory>&
|
|
|
|
duplexProtocolFactory,
|
|
|
|
int port,
|
|
|
|
boost::shared_ptr<concurrency::ThreadManager> const& threadManager =
|
|
|
|
boost::shared_ptr<concurrency::ThreadManager>(),
|
|
|
|
int nWorkers = T_ASYNC_DEFAULT_WORKER_THREADS,
|
|
|
|
THRIFT_OVERLOAD_IF(Processor, TProcessor)) :
|
|
|
|
apache::thrift::server::TServer(processor),
|
|
|
|
maxConnectionPoolSize_(T_ASYNC_MAX_CONNECTION_POOL_SIZE),
|
|
|
|
port_(port),
|
|
|
|
socket_(NULL),
|
|
|
|
serveEventBase_(NULL),
|
|
|
|
nWorkers_(nWorkers),
|
|
|
|
timeout_(0),
|
|
|
|
eventBaseManager_(),
|
|
|
|
workerChoice_(0),
|
|
|
|
maxFrameSize_(T_ASYNC_DEFAULT_MAX_FRAME_SIZE),
|
|
|
|
readBufferDefaultSize_(T_ASYNC_READ_BUFFER_DEFAULT_SIZE),
|
|
|
|
writeBufferDefaultSize_(T_ASYNC_WRITE_BUFFER_DEFAULT_SIZE),
|
|
|
|
idleReadBufferLimit_(T_ASYNC_IDLE_READ_BUFFER_LIMIT),
|
|
|
|
idleWriteBufferLimit_(T_ASYNC_IDLE_WRITE_BUFFER_LIMIT),
|
|
|
|
resizeBufferEveryN_(T_ASYNC_RESIZE_BUFFER_EVERY_N),
|
|
|
|
callTimeout_(0),
|
|
|
|
taskExpireTime_(0),
|
|
|
|
queuingMode_(true),
|
|
|
|
acceptRateAdjustSpeed_(0),
|
|
|
|
maxNumMsgsInPipe_(T_MAX_NUM_MESSAGES_IN_PIPE),
|
2012-07-10 19:19:49 +02:00
|
|
|
maxNumActiveConnectionsPerWorker_(0),
|
2012-07-03 07:45:59 +02:00
|
|
|
transportType_(T_ASYNC_DEFAULT_TRANSPORT_TYPE) {
|
|
|
|
setDuplexProtocolFactory(duplexProtocolFactory);
|
|
|
|
setThreadManager(threadManager);
|
|
|
|
}
|
|
|
|
|
|
|
|
virtual ~TEventServer() {
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
void setSSLContext(boost::shared_ptr<transport::SSLContext> context) {
|
|
|
|
sslContext_ = context;
|
|
|
|
}
|
|
|
|
|
|
|
|
boost::shared_ptr<transport::SSLContext> getSSLContext() const {
|
|
|
|
return sslContext_;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Use the provided socket rather than binding to port_. The caller must
|
|
|
|
* call ::bind on this socket, but should not call ::listen.
|
|
|
|
*
|
|
|
|
* NOTE: TEventServe takes ownership of this 'socket' so if binding fails
|
|
|
|
* we destroy this socket, while cleaning itself up. So, 'accept' better
|
|
|
|
* work the first time :)
|
|
|
|
*/
|
|
|
|
void useExistingSocket(int socket);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Return the file descriptor associated with the listening socket
|
|
|
|
*/
|
|
|
|
int getListenSocket() const;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Get the TAsyncProcessorFactory object used by this server.
|
|
|
|
*
|
|
|
|
* @return a pointer to the processorFactory.
|
|
|
|
*/
|
|
|
|
boost::shared_ptr<TAsyncProcessorFactory> getAsyncProcessorFactory() const {
|
|
|
|
return asyncProcessorFactory_;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Set the TAsyncProcessor object used by this server.
|
|
|
|
*/
|
|
|
|
void setAsyncProcessorFactory(boost::shared_ptr<TAsyncProcessorFactory> pf) {
|
|
|
|
asyncProcessorFactory_ = pf;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Get the TEventBase used by the current thread.
|
|
|
|
* This will be different between each worker and the listener. Use this
|
|
|
|
* for any event monitoring within a processor and be careful NOT to
|
|
|
|
* cache between connections (since they may be executed by different
|
|
|
|
* workers).
|
|
|
|
*
|
|
|
|
* @return a pointer to the TEventBase.
|
|
|
|
*/
|
|
|
|
TEventBase* getEventBase() const {
|
|
|
|
return eventBaseManager_.getEventBase();
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Get the TEventServer's main event base.
|
|
|
|
*
|
|
|
|
* @return a pointer to the TEventBase.
|
|
|
|
*/
|
|
|
|
TEventBase* getServeEventBase() const {
|
|
|
|
return serveEventBase_;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Get the TEventBaseManager used by this server.
|
|
|
|
* This can be used to find or create the TEventBase associated with
|
|
|
|
* any given thread, including any new threads created by clients.
|
|
|
|
*
|
|
|
|
* @return a pointer to the TEventBaseManager.
|
|
|
|
*/
|
|
|
|
TEventBaseManager* getEventBaseManager() {
|
|
|
|
return &eventBaseManager_;
|
|
|
|
}
|
|
|
|
const TEventBaseManager* getEventBaseManager() const {
|
|
|
|
return &eventBaseManager_;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Set the port to serve
|
|
|
|
*/
|
|
|
|
void setPort(uint16_t port) {
|
|
|
|
port_ = port ;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
*Set the maximum number of inactive connection objects pooled.
|
|
|
|
* Since these objects consume memory, we need to limit how many we keep.
|
|
|
|
* You can disable pooling altogether by setting this to zero. Note that
|
|
|
|
* the actual maximum is nWorkers*size since each worker thread maintains
|
|
|
|
* its own pool (to avoid the need for locks).
|
|
|
|
*
|
|
|
|
* @param size the maximum number of inactive connections to pool.
|
|
|
|
*/
|
|
|
|
void setMaxConnectionPoolSize(uint32_t size) {
|
|
|
|
maxConnectionPoolSize_ = size;
|
|
|
|
}
|
|
|
|
|
|
|
|
/** Get the maximum number of inactive connection objects pooled.
|
|
|
|
@return the maximum pool size.
|
|
|
|
*/
|
|
|
|
uint32_t getMaxConnectionPoolSize() const {
|
|
|
|
return maxConnectionPoolSize_;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Get the maximum number of unprocessed messages which a NotificationPipe
|
|
|
|
* can hold.
|
|
|
|
*/
|
|
|
|
uint32_t getMaxNumMessagesInPipe() const {
|
|
|
|
return maxNumMsgsInPipe_;
|
|
|
|
}
|
|
|
|
/**
|
|
|
|
* Set the maximum number of unprocessed messages in NotificationPipe.
|
|
|
|
* No new message will be sent to that NotificationPipe if there are more
|
|
|
|
* than such number of unprocessed messages in that pipe.
|
|
|
|
*/
|
|
|
|
void setMaxNumMessagesInPipe(uint32_t num) {
|
|
|
|
maxNumMsgsInPipe_ = num;
|
|
|
|
}
|
|
|
|
|
2012-07-10 19:19:49 +02:00
|
|
|
/**
|
|
|
|
* Get the maxmum number of active connections each TAsyncWorker can have
|
|
|
|
*/
|
|
|
|
int32_t getMaxNumActiveConnectionsPerWorker() const {
|
|
|
|
return maxNumActiveConnectionsPerWorker_;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Set the maxmum number of active connections each TAsyncWorker can have.
|
|
|
|
* Zero means unlimited
|
|
|
|
*/
|
|
|
|
void setMaxNumActiveConnectionsPerWorker(int32_t num) {
|
|
|
|
maxNumActiveConnectionsPerWorker_ = num;
|
|
|
|
}
|
|
|
|
|
2012-07-03 07:45:59 +02:00
|
|
|
/**
|
|
|
|
* Get the speed of adjusting connection accept rate.
|
|
|
|
*/
|
|
|
|
double getAcceptRateAdjustSpeed() const {
|
|
|
|
return acceptRateAdjustSpeed_;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Set the speed of adjusting connection accept rate.
|
|
|
|
*/
|
|
|
|
void setAcceptRateAdjustSpeed(double speed) {
|
|
|
|
acceptRateAdjustSpeed_ = speed;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Get the number of connections dropped by the TAsyncServerSocket
|
|
|
|
*/
|
|
|
|
void getNumDroppedConnections() const;
|
|
|
|
|
|
|
|
/** Reset the maximum number of inactive connection objects to the default.
|
|
|
|
*/
|
|
|
|
void resetMaxConnectionPoolSize() {
|
|
|
|
setMaxConnectionPoolSize(T_ASYNC_MAX_CONNECTION_POOL_SIZE);
|
|
|
|
}
|
|
|
|
|
|
|
|
/** Get maximum number of milliseconds we'll wait for data (0 = infinity).
|
|
|
|
*
|
|
|
|
* @return number of milliseconds, or 0 if no timeout set.
|
|
|
|
*/
|
|
|
|
int getRecvTimeout() const {
|
|
|
|
return timeout_;
|
|
|
|
}
|
|
|
|
|
|
|
|
/** Set maximum number of milliseconds we'll wait for data (0 = infinity).
|
|
|
|
* Note: existing connections are unaffected by this call.
|
|
|
|
*
|
|
|
|
* @param timeout number of milliseconds, or 0 to disable timeouts.
|
|
|
|
*/
|
|
|
|
void setRecvTimeout(int timeout) {
|
|
|
|
timeout_ = timeout;
|
|
|
|
}
|
|
|
|
|
|
|
|
/** Set the maximum frame size server will accept.
|
|
|
|
*
|
|
|
|
* @param size the maximum size in bytes of a frame we'll accept.
|
|
|
|
*/
|
|
|
|
void setMaxFrameSize(uint32_t size) {
|
|
|
|
maxFrameSize_ = size;
|
|
|
|
}
|
|
|
|
|
|
|
|
/** Get the maximum frame size server will accept.
|
|
|
|
*
|
|
|
|
* @return the maximum pool size.
|
|
|
|
*/
|
|
|
|
uint32_t getMaxFrameSize() const {
|
|
|
|
return maxFrameSize_;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Get the starting size of a TEventConnection object's read buffer.
|
|
|
|
*
|
|
|
|
* @return # bytes we init a TEventConnection object's read buffer to.
|
|
|
|
*/
|
|
|
|
size_t getReadBufferDefaultSize() const {
|
|
|
|
return readBufferDefaultSize_;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Set the starting size of a TEventConnection object's read buffer.
|
|
|
|
*
|
|
|
|
* @param size # bytes we init a TEventConnection object's read buffer to.
|
|
|
|
*/
|
|
|
|
void setReadBufferDefaultSize(size_t size) {
|
|
|
|
readBufferDefaultSize_ = size;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Get the starting size of a TEventConnection object's write buffer.
|
|
|
|
*
|
|
|
|
* @return # bytes we init a TEventConnection object's write buffer to.
|
|
|
|
*/
|
|
|
|
size_t getWriteBufferDefaultSize() const {
|
|
|
|
return writeBufferDefaultSize_;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Set the starting size of a TEventConnection object's write buffer.
|
|
|
|
*
|
|
|
|
* @param size # bytes we init a TEventConnection object's write buffer to.
|
|
|
|
*/
|
|
|
|
void setWriteBufferDefaultSize(size_t size) {
|
|
|
|
writeBufferDefaultSize_ = size;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Get the maximum size of read buffer allocated to idle TConnection objects.
|
|
|
|
*
|
|
|
|
* @return # bytes beyond which we will shrink buffers when idle.
|
|
|
|
*/
|
|
|
|
size_t getIdleReadBufferLimit() const {
|
|
|
|
return idleReadBufferLimit_;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Set the maximum size read buffer allocated to idle TEventConnection
|
|
|
|
* objects. If a TEventConnection object is found (either on connection
|
|
|
|
* close or between calls when resizeBufferEveryN_ is set) with more than
|
|
|
|
* this much memory
|
|
|
|
* allocated to its read buffer, we shrink it to this value.
|
|
|
|
*
|
|
|
|
* @param limit of bytes beyond which we will shrink buffers when checked.
|
|
|
|
*/
|
|
|
|
void setIdleReadBufferLimit(size_t limit) {
|
|
|
|
idleReadBufferLimit_ = limit;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Get the maximum size of write buffer allocated to idle TEventConnection
|
|
|
|
* objects.
|
|
|
|
*
|
|
|
|
* @return # bytes beyond which we will reallocate buffers when checked.
|
|
|
|
*/
|
|
|
|
size_t getIdleWriteBufferLimit() const {
|
|
|
|
return idleWriteBufferLimit_;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Set the maximum size write buffer allocated to idle TEventConnection
|
|
|
|
* objects. If a TEventConnection object is found (either on connection
|
|
|
|
* close or between calls when resizeBufferEveryN_ is set) with more than
|
|
|
|
* this much memory allocated to its write buffer, we destroy and construct
|
|
|
|
* that buffer.
|
|
|
|
*
|
|
|
|
* @param limit of bytes beyond which we will shrink buffers when idle.
|
|
|
|
*/
|
|
|
|
void setIdleWriteBufferLimit(size_t limit) {
|
|
|
|
idleWriteBufferLimit_ = limit;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Get # of calls made between buffer size checks. 0 means disabled.
|
|
|
|
*
|
|
|
|
* @return # of calls between buffer size checks.
|
|
|
|
*/
|
|
|
|
int32_t getResizeBufferEveryN() const {
|
|
|
|
return resizeBufferEveryN_;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Check buffer sizes every "count" calls. This allows buffer limits
|
|
|
|
* to be enforced for persistant connections with a controllable degree
|
|
|
|
* of overhead. 0 disables checks except at connection close.
|
|
|
|
*
|
|
|
|
* @param count the number of calls between checks, or 0 to disable
|
|
|
|
*/
|
|
|
|
void setResizeBufferEveryN(int32_t count) {
|
|
|
|
resizeBufferEveryN_ = count;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Set a call timeout in milliseconds.
|
|
|
|
*
|
|
|
|
* When a worker's TEventBase starts taking longer than this amount of time
|
|
|
|
* to process a single loop, start dropping connections to reduce loadj
|
|
|
|
*
|
|
|
|
* TODO: This should be renamed something other than "call timeout"
|
|
|
|
*
|
|
|
|
* @param milliseconds the call timeout (0 inhibits)
|
|
|
|
*/
|
|
|
|
void setCallTimeout(int32_t milliseconds) {
|
|
|
|
callTimeout_ = milliseconds;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Get the call timeout in milliseconds. 0 (default) disables.
|
|
|
|
*
|
|
|
|
* @return the call timeout in milliseconds
|
|
|
|
*/
|
|
|
|
int32_t getCallTimeout() const {
|
|
|
|
return callTimeout_;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Set Thread Manager (for queuing mode).
|
|
|
|
*
|
|
|
|
* @param threadManager a shared pointer to the thread manager
|
|
|
|
*/
|
|
|
|
void setThreadManager(boost::shared_ptr<concurrency::ThreadManager>
|
|
|
|
threadManager) {
|
|
|
|
threadManager_ = threadManager;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Get Thread Manager (for queuing mode).
|
|
|
|
*
|
|
|
|
* @return a shared pointer to the thread manager
|
|
|
|
*/
|
|
|
|
boost::shared_ptr<concurrency::ThreadManager> getThreadManager() {
|
|
|
|
return threadManager_;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Get the task expire time (for queuing mode).
|
|
|
|
*
|
|
|
|
* @return task expire time
|
|
|
|
*/
|
|
|
|
int64_t getTaskExpireTime() const {
|
|
|
|
return taskExpireTime_;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Return whether we are in queuing mode or not.
|
|
|
|
*
|
|
|
|
* @return true if we are in queuing mode, false if not.
|
|
|
|
*/
|
|
|
|
bool queuingMode() const {
|
|
|
|
return queuingMode_;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Set the transport type to use
|
|
|
|
*
|
|
|
|
* @param transportType transport type
|
|
|
|
*/
|
|
|
|
void setTransportType(TransportType transportType) {
|
|
|
|
|
|
|
|
/*********** Deprecation Warning *******************
|
|
|
|
* *
|
|
|
|
* The unframed transports are deprecated ! *
|
|
|
|
* They should be used for legancy services only *
|
|
|
|
* Also note: they only works with TBinaryProtocol *
|
|
|
|
***************************************************/
|
|
|
|
|
|
|
|
if (transportType == UNFRAMED_BINARY &&
|
|
|
|
!dynamic_cast<apache::thrift::protocol::TBinaryProtocolFactoryBase*>(
|
|
|
|
getDuplexProtocolFactory()->getInputProtocolFactory().get())) {
|
|
|
|
throw TLibraryException(
|
|
|
|
"UnFramedTransport can only be used with TBinaryProtocol");
|
|
|
|
} else if (transportType == HEADER &&
|
|
|
|
!dynamic_cast<apache::thrift::protocol::THeaderProtocolFactory*>(
|
|
|
|
getDuplexProtocolFactory()->getInputProtocolFactory().get())) {
|
|
|
|
throw TLibraryException(
|
|
|
|
"HEADER transport can only be used with THeaderProtocol");
|
|
|
|
}
|
|
|
|
|
|
|
|
transportType_ = transportType;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Get the transport type to use
|
|
|
|
*
|
|
|
|
* @return transport type
|
|
|
|
*/
|
|
|
|
TransportType getTransportType() {
|
|
|
|
return transportType_;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Call this to complete initialization
|
|
|
|
*/
|
|
|
|
void setup();
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Kill the workers and wait for listeners to quit
|
|
|
|
*/
|
|
|
|
void cleanUp();
|
|
|
|
|
|
|
|
/**
|
|
|
|
* One stop solution:
|
|
|
|
*
|
|
|
|
* starts worker threads, enters accept loop; when
|
|
|
|
* the accept loop exits, shuts down and joins workers.
|
|
|
|
*/
|
|
|
|
void serve();
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Call this to stop the server, if started by serve()
|
|
|
|
*
|
|
|
|
* This causes the main serve() function to stop listening for new
|
|
|
|
* connections, closes existing connections, shut down the worker threads,
|
|
|
|
* and then return.
|
|
|
|
*/
|
|
|
|
void stop();
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Call this to stop listening on the server port.
|
|
|
|
*
|
|
|
|
* This causes the main serve() function to stop listening for new
|
|
|
|
* connections while still allows the worker threads to process
|
|
|
|
* existing connections. stop() still needs to be called to clear
|
|
|
|
* up the worker threads.
|
|
|
|
*/
|
|
|
|
void stopListening();
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Terminate a given pending task. Callable by the thread manager or
|
|
|
|
* from the server context.
|
|
|
|
*/
|
|
|
|
void expireClose(
|
|
|
|
boost::shared_ptr<apache::thrift::concurrency::Runnable> task);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* In task queue mode, drop a task from the head of the queue and shut
|
|
|
|
* down the associated connection.
|
|
|
|
*/
|
|
|
|
bool drainPendingTask();
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Get the TConnectionContext for the connection currently being processed.
|
|
|
|
*
|
|
|
|
* This is intended to be invoked from within the TAsyncProcessor (or the
|
|
|
|
* handler used by the TProcessor).
|
|
|
|
*
|
|
|
|
* @return Return a pointer to the TConnectionContext for the current
|
|
|
|
* connection, or NULL if invoked outside of a call to
|
|
|
|
* TAsyncProcessor::process(). The returned TConnectionContext
|
|
|
|
* object is guaranteed to remain valid until the
|
|
|
|
* TAsyncProcessor invokes its success or error callback. However,
|
|
|
|
* getConnectionContext() may return NULL when invoked after
|
|
|
|
* process() has returned.
|
|
|
|
*
|
|
|
|
* In other words, async handlers may continue using the
|
|
|
|
* TConnectionContext object for the duration of the handler
|
|
|
|
* processing. However, they must retrieve the TConnectionContext
|
|
|
|
* inside the call to process() and cache it for later use if
|
|
|
|
* they need it later.
|
|
|
|
*/
|
|
|
|
virtual server::TConnectionContext* getConnectionContext() const;
|
|
|
|
|
|
|
|
// We use this to get the processor when in task queue mode
|
|
|
|
using TServer::getProcessor;
|
|
|
|
};
|
|
|
|
|
|
|
|
}}} // apache::thrift::async
|
|
|
|
|
|
|
|
#endif // #ifndef THRIFT_ASYNC_TEVENTSERVER_H_
|