def start_server(self):
"""
Registers the host and root scheduler processors and
starts the thrift server.
"""
mux_processor = TMultiplexedProcessor.TMultiplexedProcessor()
if self._hostHandler:
self._register_processer("Host", mux_processor)
if self._leafSchedulerHandler:
self._register_processer("Scheduler", mux_processor)
if self._rootSchedulerHandler:
self._register_processer("RootScheduler", mux_processor)
if self._enable_ping:
self._register_processer("AgentControl", mux_processor)
transport = TSocket.TServerSocket(self._address, self._port)
protocol_factory = TCompactProtocol.TCompactProtocolFactory()
self._server = TNonblockingServer.TNonblockingServer(
mux_processor, transport, protocol_factory, protocol_factory)
self._thread = threading.Thread(target=self._server.serve)
self._thread.daemon = True
self._thread.start()
self._server_started = True
self._logger.info(
"[ThriftServer] Thrift server started. Address: {0} Port: {1}".
format(self._address, self._port))
def _initialize_thrift_service(self):
""" Initialize the thrift server. """
mux_processor = TMultiplexedProcessor.TMultiplexedProcessor()
for plugin in thrift_services():
self._logger.info("Load thrift services %s (num_threads: %d)",
plugin.name, plugin.num_threads)
handler = plugin.handler
processor = plugin.service.Processor(handler)
mux_processor.registerProcessor(plugin.name, processor)
self._logger.info(
"Initialize SSLSocket using certfile=%s, keyfile=%s, capath=%s" %
(SSL_CERT_FILE, SSL_KEY_FILE, CA_PATH))
transport = TSSLSocket.TSSLServerSocket(port=self._config.host_port,
certfile=SSL_CERT_FILE,
keyfile=SSL_KEY_FILE,
capath=CA_PATH,
ciphers=SSL_CIPHERS)
protocol_factory = TCompactProtocol.TCompactProtocolFactory()
server = TNonblockingServer.TNonblockingServer(
mux_processor, transport, protocol_factory, protocol_factory,
self._config.host_service_threads)
self._server = server
def __init__(self, net: CaptchaBreaker, adPredictor: AdPredictor, host='127.0.0.1', port=48519):
handler = APITransmitHandler(net, adPredictor)
processor = BackendBridge.Processor(handler)
transport = TSocket.TServerSocket(host, port)
self.server = TNonblockingServer.TNonblockingServer(processor, transport)
pass
def run(args):
log_level = get_log_level(args.log_level)
logger = logging.getLogger()
logger.setLevel(log_level)
if args.verbose:
ch = logging.StreamHandler()
ch.setLevel(log_level)
formatter = logging.Formatter(
'%(asctime)s - %(name)s - %(levelname)s - %(message)s')
ch.setFormatter(formatter)
logger.addHandler(ch)
logging.info("Starting pysnowflake server %s:%d" % (args.host, args.port))
handler = IdWorker(args.worker_id, args.data_center_id)
processor = Snowflake.Processor(handler)
transport = TSocket.TServerSocket(port=args.port)
tfactory = TTransport.TBufferedTransportFactory()
pfactory = TBinaryProtocol.TBinaryProtocolFactory()
logging.info("logging level: %s" % args.log_level)
server = TNonblockingServer.TNonblockingServer(processor,
transport,
pfactory,
threads=1)
logging.info("RUNNING")
server.serve()
def threaded_function():
handler = LucidaServiceHandler()
processor = LucidaService.Processor(handler)
transport = TSocket.TServerSocket(port=8080)
tfactory = TTransport.TBufferedTransportFactory()
pfactory = TBinaryProtocol.TBinaryProtocolFactory()
server = TNonblockingServer.TNonblockingServer(processor, transport, pfactory, pfactory)
print 'CMD at', str(8080)
server.serve()
def __init__(self, processor, port):
self.processor = processor
self.transport = TSocket.TServerSocket(port=port)
self.tfactory = TTransport.TBufferedTransportFactory()
self.pfactory = TBinaryProtocol.TBinaryProtocolFactory()
#self.server = TServer.TThreadPoolServer(self.processor, self.transport , self.tfactory, self.pfactory)
#self.server = TServer.TSimpleServer(self.processor, self.transport , self.tfactory, self.pfactory)
self.server = TNonblockingServer.TNonblockingServer(
self.processor, self.transport)
def start_clog_service(port):
handler = CronLogServiceHandler()
processor = CronLogService.Processor(handler)
transport = TSocket.TServerSocket(port=port)
tfactory = TTransport.TBufferedTransportFactory()
tfactory = TBinaryProtocol.TBinaryProtocolFactory()
server = TNonblockingServer.TNonblockingServer(
processor, transport, threads=20)
print "Cassandra Log Server Running on port {port}...".format(port=port)
server.serve()
def run(self):
handler = BackEndHandler()
proc = Processor(handler)
trans_svr = TSocket.TServerSocket(port=self.portBE)
proto_fac = TBinaryProtocol.TBinaryProtocolFactory()
server = TNonblockingServer.TNonblockingServer(proc, trans_svr,
proto_fac)
print(f"[Server] Started on port {self.portBE}")
server.serve()
def create_rpc_server(self, ps_host_name):
sspHandler = SspHandler(self.num, self.max_stale)
handler = sspHandler
processor = CheckStaleness.Processor(handler)
transport = TSocket.TServerSocket(host=ps_host_name, port=8000)
tfactory = TTransport.TBufferedTransportFactory()
rpcServer = TNonblockingServer.TNonblockingServer(
processor, transport, threads=self.thread_num)
tf.logging.info("Listening on port 8000...")
return rpcServer
def create_rpc_server(self, ps_host_name):
batchSizeHandler = BatchSizeHandler(self.initial_batch_size,
self.num_of_replicas,
self.thread_num)
handler = batchSizeHandler
processor = UpdateBatchSize.Processor(handler)
#transport = TSocket.TServerSocket(ps_host_name, 8000)
transport = TSocket.TServerSocket(host=ps_host_name, port=8000)
tfactory = TTransport.TBufferedTransportFactory()
# tfactory = TTransport.TFramedTransportFactory()
pfactory = TBinaryProtocol.TBinaryProtocolFactory()
#rpcServer = TServer.TSimpleServer(processor,transport, tfactory, pfactory)
rpcServer = TNonblockingServer.TNonblockingServer(
processor, transport, threads=self.thread_num)
tf.logging.info("Listening on port 8000...")
return rpcServer
def serve(self):
signal.signal(signal.SIGTERM, signal_handler)
signal.signal(signal.SIGUSR1, signal_handler)
processor = self.service.Processor(self.handler)
tsocket = TSocket.TServerSocket(port=self.port)
ttransport = TCompactProtocol.TCompactProtocolFactory()
pfactory = TCompactProtocol.TCompactProtocolFactory()
server = TNonblockingServer.TNonblockingServer(processor, tsocket,
ttransport, pfactory)
server.setNumThreads(self.threads_num)
print datetime.now(
), ' Starting thrift server on port %d...' % self.port
server.serve()
print datetime.now(), ' thrift server quit.'
def main():
if len(sys.argv) < 2:
print_usage()
sys.exit(2)
config_file = sys.argv[1]
config = read_config(config_file)
# asynchronous server
handler = MindscribeHandler(config)
processor = Mindscribe.Processor(handler)
transport = TSocket.TServerSocket(config['port'])
server = TNonblockingServer.TNonblockingServer(processor, transport)
print 'Starting the server on port: ' + config['port']
server.serve()
print 'done.'
def _initialize_thrift_service(self):
""" Initialize the thrift server. """
mux_processor = TMultiplexedProcessor.TMultiplexedProcessor()
for plugin in thrift_services():
self._logger.info("Load thrift services %s (num_threads: %d)",
plugin.name, plugin.num_threads)
handler = plugin.handler
processor = plugin.service.Processor(handler)
mux_processor.registerProcessor(plugin.name, processor)
transport = TSocket.TServerSocket(port=self._config.host_port)
protocol_factory = TCompactProtocol.TCompactProtocolFactory()
server = TNonblockingServer.TNonblockingServer(
mux_processor, transport, protocol_factory, protocol_factory,
self._config.host_service_threads)
self._server = server
def run():
if not readConf():
logService.info('read conf file is failed!')
#print 'read conf file is failed!'
return None
# build news_infer_server
if not hasValidPort():
logService.info("doesn't have valid port")
#print "doesn't have valid port"
return None
handler = SameVideoHandler()
valid_port = getPort()
if valid_port == None:
logService.info("doesn't have valid port")
#print "doesn't have valid port"
return None
transport = TSocket.TServerSocket(port=valid_port)
processor = SameVideoJudgeService.Processor(handler)
#tfactory = TTransport.TBufferedTransportFactory()
tfactory = TTransport.TFramedTransportFactory()
pfactory = TBinaryProtocol.TBinaryProtocolFactory()
#server = TServer.TThreadPoolServer(processor, transport, tfactory, pfactory)
#server = TServer.TSimpleServer(processor, transport, tfactory, pfactory)
#server = TProcessPoolServer.TProcessPoolServer(processor, transport, tfactory, pfactory)
#server = TNonblockingServer.TNonblockingServer(processor, transport, tfactory, pfactory)
server = TNonblockingServer.TNonblockingServer(processor, transport,
pfactory)
server.daemon = True
server.setNumThreads(thread_num)
#server.setNumWorkers(thread_num)
print threading.current_thread()
print('Starting the infer server...')
server.serve()
#logAll.error('done.')
print('done')
def __initialize(self):
pfactory = ThriftServer.__protocol_type[self._protocol]()
if self._server_type == 'http':
self._server = THttpServer.THttpServer(\
self._processor, (self._ip, self._port), pfactory)
return
transport = TSocket.TServerSocket(self._ip, self._port)
if self._transport == 'zlib':
transport = TZlibTransport.TZlibTransport(transport)
tfactory = TZlibTransport.TZlibTransportFactory()
else:
tfactory = TTransport.TBufferedTransportFactory()
if self._server_type == 'noblock':
self._server = TNonblockingServer.TNonblockingServer(\
self._processor, transport, inputProtocolFactory=pfactory)
else:
self._server_type = ThriftServer.__server_type.get(self._server_type, 'TSimpleServer')
ServerClass = getattr(TServer, self._server_type)
self._server = ServerClass(self._processor, transport, tfactory, pfactory)
def main():
# 1. 创建 Thrift Server 的 ServeSocket
serverSocket = TSocket.TServerSocket(host=host, port=port)
# 3. 创建 Thrift Server 的 Protocol = 二进制传输协议
protocolFactory = TBinaryProtocol.TBinaryProtocolFactory()
# 4. 创建 Thrift Server 提供的处理方法
handler = SpiderServiceHandler()
# from message.api import MessageService
processor = SpiderService.Processor(handler)
# 5. 创建 Thrift Server, 指明如何处理，监听什么端口，传输方式，传输协议
# thriftServer = TServer.TSimpleServer(processor,
# serverSocket,
# transportFactory,
# protocolFactory)
thriftServer = TNonblockingServer.TNonblockingServer(
processor, serverSocket, protocolFactory, protocolFactory)
# 6. 启动 Thrift Server, 等待客户端的访问
print("Python Thrift Spider Server Start ...")
thriftServer.serve()
print("Python Thrift Spider Server Stop ...")
def _createThriftServer(self):
buf_que = deque()
handler = ScribeHandler(buf_que)
protocol_factory = TBinaryProtocol.TBinaryProtocolFactory(
False, False)
transport = TSocket.TServerSocket(host='0.0.0.0')
processor = Processor(handler)
server = TNonblockingServer.TNonblockingServer(
processor, transport, protocol_factory)
server._stop = False
while True:
try:
server.prepare()
port = transport.handle.getsockname()[1]
logger.info('get scribe port succeed: %d', port)
break
except socket.error:
pass
spawn(server.serve)
return server, port, buf_que
def init_connection(self, processor):
'''
Initialize all connections with TBinaryProtocol and TFramedTransport
Parameters
----------
processor : TProcessor
Processor class has been generated by thrift
Returns
-------
server: TServer
TNonblocking Server
'''
socket = TSocket.TServerSocket(host=self.host, port=self.port)
prot_fac = TBinaryProtocol.TBinaryProtocolFactory()
server = TNonblockingServer.TNonblockingServer(processor=processor,
lsocket=socket,
inputProtocolFactory=prot_fac,
threads=self.threads)
return server
def main():
parser = argparse.ArgumentParser("usage: %prog [options]")
parser.add_argument('-b',
'--bind',
dest='host',
metavar='ADDR',
help='IP addr or hostname to bind to')
parser.add_argument('-p',
'--port',
dest='port',
type=int,
metavar='PORT',
help='port to bind to')
parser.add_argument('-d',
'--logdir',
dest='logdir',
metavar='LOGDIR',
default='.',
help='log DIR')
parser.add_argument('-l',
'--loglevel',
dest='loglevel',
metavar='LOGLEVEL',
default='DEBUG',
help='log flag')
parser.add_argument('--thrift',
dest='use_thrift',
metavar='THRIFT',
default=True,
help='use thrift or not')
parser.add_argument('--gcfg',
dest='gcfg',
metavar='GMONDCFG',
default='/usr/local/etc/gmond.cfg',
help='gmond location')
args = parser.parse_args()
global logger
logger = slogger.get_logger(args.logdir, 'logserver', args.loglevel)
if args.use_thrift:
from common.thrift_gen.log_record import LogCollector
from thrift.transport import TSocket
from thrift.protocol import TBinaryProtocol
from thrift.server import TNonblockingServer
perf_rec_queue = Queue.Queue()
handler = LogCollectorHandler(perf_rec_queue=perf_rec_queue)
processor = LogCollector.Processor(handler)
transport = TSocket.TServerSocket(host=args.host, port=args.port) \
if args.port else TSocket.TServerSocket(unix_socket=args.host)
tfactory = TBinaryProtocol.TBinaryProtocolFactory()
pfactory = TBinaryProtocol.TBinaryProtocolFactory()
server = TNonblockingServer.TNonblockingServer(processor, transport,
tfactory, pfactory)
collector = PerfCollector(perf_rec_queue, logger)
collector.setDaemon(True)
collector.start()
cfg_path = args.gcfg
interval = 60.0
sender = GMetricSender(collector, logger, interval, cfg_path) \
if cfg_path else PerfSender(collector, logger, interval)
sender.setDaemon(True)
sender.start()
logger.info('Starting the server...')
server.serve()
logger.info('done.')
return
set_log_dir(args.logdir)
if args.port:
log_server = LogRecordTCPSocketReceiver(host=args.host, port=args.port)
logger.info("About to start tcp log server with port %s", args.port)
else:
log_server = LogRecordUnixSocketReceiver(host=args.host)
logger.info("About to start unix socket log server"
" with socket %s", args.host)
log_server.serve_until_stopped()
log_server.server_close()
sentence.tokenization = Tokenization(uuid = aug.next(),
kind = TokenizationKind.TOKEN_LIST,
tokenList = TokenList(tokenList=[]),
tokenTaggingList = [],
metadata = AnnotationMetadata(timestamp=int(time.time()), tool="nltk"))
for i, token in enumerate(nltk.word_tokenize(text)):
logging.info("Found token %s", token)
sentence.tokenization.tokenList.tokenList.append(Token(tokenIndex=i, text=token))
return communication
if __name__ == "__main__":
import argparse
parser = argparse.ArgumentParser()
parser.add_argument("-p", "--port", dest="port", type=int, default=9090)
options = parser.parse_args()
logging.basicConfig(level=logging.INFO)
handler = CommunicationHandler()
processor = Annotator.Processor(handler)
transport = TSocket.TServerSocket(port=options.port)
ipfactory = TCompactProtocol.TCompactProtocolFactory()
opfactory = TCompactProtocol.TCompactProtocolFactory()
server = TNonblockingServer.TNonblockingServer(processor, transport, ipfactory, opfactory)
logging.info('Starting the server...')
server.serve()
def __create_server(processor, ip, port):
transport = TSocket.TServerSocket(ip, port)
pfactory = TCompactProtocol.TCompactProtocolFactory()
return TNonblockingServer.TNonblockingServer(processor, transport, pfactory)
def main():
op = optparse.OptionParser(usage='%prog [options]', add_help_option=False)
op.add_option('-p',
'--port',
action='store',
type='int',
dest='port',
default=1234,
help='The server port')
op.add_option('-s',
'--servertype',
action='store',
type='string',
dest='servertype',
default='TGeventServer',
help='Type name of server')
op.add_option('-w',
'--num_workers',
action='store',
type='int',
dest='workers',
default=4,
help='Number of worker processes')
op.add_option('-Q',
'--max_queue_size',
action='store',
type='int',
dest='max_queue_size',
default=0,
help='Max queue size, passed to TNonblockingServer')
op.add_option('-h',
'--header',
action='store_true',
help='Use the generated ContextIface')
op.add_option('-?',
'--help',
action='help',
help='Show this help message and exit')
(options, args) = op.parse_args()
if args:
op.error('trailing arguments: ' + ' '.join(args))
handler = LoadHandler()
if options.servertype == 'TGeventServer':
# only import TGeventServer when necessary. TGeventServer calls
# monkey_patch, which breaks other servers
from apache.thrift.test.sync_load_handler import GeventLoadHandler
from thrift.server import TGeventServer
handler = GeventLoadHandler()
processor = LoadTest.Processor(handler)
if options.header:
pfactory = THeaderProtocolFactory(True, \
[THeaderTransport.HEADERS_CLIENT_TYPE,
THeaderTransport.FRAMED_DEPRECATED,
THeaderTransport.UNFRAMED_DEPRECATED,
THeaderTransport.HTTP_CLIENT_TYPE])
if options.servertype == 'TNonblockingServer':
print 'Header transport, backwards compatible with framed'
else:
print 'Header transport, backwards compatible with ' + \
'unframed, framed, http'
else:
if options.servertype == 'TNonblockingServer':
print 'Framed transport'
else:
print 'Unframed transport'
pfactory = TBinaryProtocolAcceleratedFactory()
transport = TSocket.TServerSocket(options.port)
tfactory = TTransport.TBufferedTransportFactory()
if options.servertype == "TNonblockingServer":
server = TNonblockingServer.TNonblockingServer(
processor,
transport,
pfactory,
maxQueueSize=options.max_queue_size)
elif options.servertype == "TProcessPoolServer":
server = TProcessPoolServer.TProcessPoolServer(processor, transport,
tfactory, pfactory)
print 'Worker processes: ' + str(options.workers)
server.setNumWorkers(options.workers)
elif options.servertype == "TGeventServer":
print 'Worker processes: ' + str(options.workers)
# Gevent makes its own server transport.
server = TGeventServer.TGeventServer(options.port, processor, None,
tfactory, pfactory)
server.setNumWorkers(options.workers)
else:
ServerClass = getattr(TServer, options.servertype)
server = ServerClass(processor, transport, tfactory, pfactory)
print 'Serving ' + options.servertype + \
' requests on port %d...' % (options.port,)
server.serve()
def main():
op = optparse.OptionParser(usage='%prog [options]', add_help_option=False)
op.add_option('-p',
'--port',
action='store',
type='int',
dest='port',
default=1234,
help='The server port')
op.add_option('-s',
'--servertype',
action='store',
type='string',
dest='servertype',
default='TNonblockingServer',
help='Type name of server')
op.add_option('-w',
'--num_workers',
action='store',
type='int',
dest='workers',
default=4,
help='Number of worker processes/threads')
op.add_option('-Q',
'--max_queue_size',
action='store',
type='int',
dest='max_queue_size',
default=0,
help='Max queue size, passed to TNonblockingServer')
op.add_option('-h',
'--header',
action='store_true',
help='Use the generated ContextIface')
op.add_option('-?',
'--help',
action='help',
help='Show this help message and exit')
(options, args) = op.parse_args()
if args:
op.error('trailing arguments: ' + ' '.join(args))
handler = LoadHandler()
processor = LoadTest.Processor(handler)
if options.header:
pfactory = THeaderProtocolFactory(True, [
CLIENT_TYPE.HEADER, CLIENT_TYPE.FRAMED_DEPRECATED,
CLIENT_TYPE.UNFRAMED_DEPRECATED, CLIENT_TYPE.HTTP_SERVER
])
if options.servertype == 'TCppServer':
print('C++ ThriftServer, Header transport, backwards compatible '
'with all other types')
elif options.servertype == 'TNonblockingServer':
print('Header transport, backwards compatible with framed')
else:
print('Header transport, backwards compatible with ' +
'unframed, framed, http')
else:
if options.servertype == 'TCppServer':
if not options.header:
op.error('TCppServer cannot be used without header')
elif options.servertype == 'TNonblockingServer':
print('Framed transport')
else:
print('Unframed transport')
pfactory = TBinaryProtocolAcceleratedFactory()
if options.servertype == 'TCppServer':
server = TCppServer.TCppServer(processor)
server.setPort(options.port)
print('Worker threads: ' + str(options.workers))
server.setNumIOWorkerThreads(options.workers)
else:
transport = TSocket.TServerSocket(options.port)
tfactory = TTransport.TBufferedTransportFactory()
if options.servertype == "TNonblockingServer":
server = TNonblockingServer.TNonblockingServer(
processor,
transport,
pfactory,
maxQueueSize=options.max_queue_size)
elif options.servertype == "TProcessPoolServer":
server = TProcessPoolServer.TProcessPoolServer(
processor, transport, tfactory, pfactory)
print('Worker processes: ' + str(options.workers))
server.setNumWorkers(options.workers)
else:
ServerClass = getattr(TServer, options.servertype)
server = ServerClass(processor, transport, tfactory, pfactory)
print('Serving ' + options.servertype + ' requests on port %d...' %
(options.port, ))
server.serve()
def __init__(self):
handler = Handler()
processor = TestServer.Processor(handler)
transport = TSocket.TServerSocket("127.0.0.1", 30030)
self.server = TNonblockingServer.TNonblockingServer(
processor, transport)
except:
print("Could not load THttpServer")
raise
else:
if options.ssl:
cert_path = 'thrift/test/py/test_cert.pem'
transport = TSSLSocket.TSSLServerSocket(options.port,
certfile=cert_path)
else:
transport = TSocket.TServerSocket(options.port)
tfactory = TTransport.TBufferedTransportFactory()
server_class_name = args[0]
if args[0] == "TNonblockingServer":
server = TNonblockingServer.TNonblockingServer(
handler, transport, pfactory, readTimeout=options.timeout)
elif args[0] == "TProcessPoolServer":
server = TProcessPoolServer.TProcessPoolServer(
handler, transport, tfactory, pfactory)
else:
ServerClass = getattr(TServer, server_class_name)
server = ServerClass(handler, transport, tfactory, pfactory)
if options.header:
server.processor.setEventHandler(HeaderEventHandler())
elif options.context:
server.processor.setEventHandler(ContextEventHandler())
server.serverEventHandler = event_handler
server.serve()
if options.trans == 'buffered':
tfactory = TTransport.TBufferedTransportFactory()
elif options.trans == 'framed':
tfactory = TTransport.TFramedTransportFactory()
elif options.trans == '':
raise AssertionError('Unknown --transport option: %s' % options.trans)
else:
tfactory = TTransport.TBufferedTransportFactory()
# if --zlib, then wrap server transport, and use a different transport factory
if options.zlib:
transport = TZlibTransport.TZlibTransport(transport) # wrap with zlib
tfactory = TZlibTransport.TZlibTransportFactory()
# do server-specific setup here:
if server_type == "TNonblockingServer":
server = TNonblockingServer.TNonblockingServer(
processor, transport, inputProtocolFactory=pfactory)
elif server_type == "TProcessPoolServer":
import signal
from thrift.server import TProcessPoolServer
server = TProcessPoolServer.TProcessPoolServer(processor, transport,
tfactory, pfactory)
server.setNumWorkers(5)
def set_alarm():
def clean_shutdown(signum, frame):
for worker in server.workers:
if options.verbose > 0:
print 'Terminating worker: %s' % worker
worker.terminate()
if options.verbose > 0:
print 'Requesting server to stop()'
def testSet(self, thing):
return thing
def testList(self, thing):
return thing
def testEnum(self, thing):
return thing
def testTypedef(self, thing):
return thing
pfactory = TBinaryProtocol.TBinaryProtocolFactory()
handler = TestHandler()
processor = ThriftTest.Processor(handler)
if sys.argv[1] == "THttpServer":
server = THttpServer.THttpServer(processor, ('', 9090), pfactory)
else:
transport = TSocket.TServerSocket(9090)
tfactory = TTransport.TBufferedTransportFactory()
if sys.argv[1] == "TNonblockingServer":
server = TNonblockingServer.TNonblockingServer(processor, transport)
else:
ServerClass = getattr(TServer, sys.argv[1])
server = ServerClass(processor, transport, tfactory, pfactory)
server.serve()
fh.setLevel(logging.INFO)
# create console handler with a higher log level
ch = logging.StreamHandler()
ch.setLevel(logging.INFO) # handler = PingHandler()
# create formatter and add it to the handlers
formatter = logging.Formatter(
'%(asctime)s - %(name)s - %(levelname)s - %(message)s')
fh.setFormatter(formatter)
ch.setFormatter(formatter)
# add the handlers to the logger
logger.addHandler(fh)
logger.addHandler(ch)
handler = movie_service_impl.MovieServiceHandler()
processor = MovieService.Processor(handler)
# processor = Ping.Processor(handler)
transport = TSocket.TServerSocket(host="127.0.0.1", port=9090)
t_factory = TBinaryProtocol.TBinaryProtocolFactory()
p_factory = TBinaryProtocol.TBinaryProtocolAcceleratedFactory()
server = TNonblockingServer.TNonblockingServer(processor,
transport,
t_factory,
p_factory,
threads=100)
print 'Starting server'
server.serve()
elif args[0] == "TCppServer":
server = TCppServer.TCppServer(processor)
server.setPort(options.port)
else:
if options.ssl:
cert_path = 'thrift/test/py/test_cert.pem'
transport = TSSLSocket.TSSLServerSocket(options.port,
certfile=cert_path)
else:
transport = TSocket.TServerSocket(options.port)
tfactory = TTransport.TBufferedTransportFactory()
server_class_name = args[0]
if args[0] == "TNonblockingServer":
server = TNonblockingServer.TNonblockingServer(
processor, transport, pfactory, readTimeout=options.timeout)
elif args[0] == "TProcessPoolServer":
server = TProcessPoolServer.TProcessPoolServer(
processor, transport, tfactory, pfactory)
else:
ServerClass = getattr(TServer, server_class_name)
server = ServerClass(processor, transport, tfactory, pfactory)
if options.header:
server.processor.setEventHandler(HeaderEventHandler())
elif options.context:
server.processor.setEventHandler(ContextEventHandler())
server.setServerEventHandler(event_handler)
server.serve()
return True
except smtplib.SMTPException as e:
print("send email failed!")
print(e)
return False
if __name__ == "__main__":
# 1. 创建 Thrift Server 的 ServeSocket
serverSocket = TSocket.TServerSocket(host=host, port=port)
# serverSocket = TSocket.TServerSocket(None, port="9090")
# 2. 创建 Thrift Server 的 Transport = 帧传输方式
transportFactory = TTransport.TFramedTransportFactory()
# 3. 创建 Thrift Server 的 Protocol = 二进制传输协议
protocolFactory = TBinaryProtocol.TBinaryProtocolFactory()
# 4. 创建 Thrift Server 提供的处理方法
handler = MessageServiceHandler()
# from message.api import MessageService
processor = MessageService.Processor(handler)
# 5. 创建 Thrift Server, 指明如何处理，监听什么端口，传输方式，传输协议
# thriftServer = TServer.TSimpleServer(processor,
# serverSocket,
# transportFactory,
# protocolFactory)
thriftServer = TNonblockingServer.TNonblockingServer(
processor, serverSocket, protocolFactory, protocolFactory)
# 6. 启动 Thrift Server, 等待客户端的访问
print("Python Thrift Server start ...")
thriftServer.serve()
print("Python Thrift Server stop ...")