def start_tcp_server(port):
scoring_handler = TCPHandler()
server = TServer.TForkingServer(
ScoringService.Processor(scoring_handler),
TSocket.TServerSocket(port=port),
TTransport.TBufferedTransportFactory(),
TBinaryProtocol.TBinaryProtocolFactory(),
)
print('TCP scoring service listening on port {}...'.format(port))
server.serve()
def BuildTserver(ip, port):
handler = RiskModelHandler()
processor = RiskModelThriftService.Processor(handler)
transport = TSocket.TServerSocket(ip, port)
tfactory = TTransport.TBufferedTransportFactory()
pfactory = TBinaryProtocol.TBinaryProtocolFactory()
# server = TServer.TThreadedServer(processor, transport, tfactory, pfactory)
server = TServer.TForkingServer(processor, transport, tfactory, pfactory)
# logging.info("Starting python server with TThreadedServer...")
logging.info("Starting python server with TForkingServer...")
server.serve()
def _run(self):
handler = EasyHadoopHandler()
processor = EasyHadoop.Processor(handler)
transport = TSocket.TServerSocket(self.host, self.port)
tfactory = TTransport.TBufferedTransportFactory()
pfactory = TBinaryProtocol.TBinaryProtocolFactory()
server = TServer.TForkingServer(processor, transport, tfactory,
pfactory)
cherrypy.config.update(self.settings)
cherrypy.tree.mount(Index(), '/')
cherrypy.tree.mount(Node(), '/node')
cherrypy.tree.mount(Jmx(), '/jmx')
cherrypy.tree.mount(Token(), '/token')
#cherrypy.tree.mount(Expect(), '/expect')
cherrypy.engine.start()
server.serve()
def open_thrift_server(processor, handler, port, server_type, num_threads=None):
'''
실제 Thrift Server 를 생성한다.
@type processor: Class (Thrift Interface)
@param processor: 자동으로 생성된 Thrift Service Class
@type handler: Class
@param handler: Thrift Interface 에 연결되어 실제 수행될 함수들이 있는 Class
@type port: int
@param port: Thrift server 를 bind 할 포트
@type server_type: str
@param server_type: in ["TThreadedServer", "TForkingServer", "TThreadPoolServer"]
@type num_threads: int
@param num_threads: TThreadPoolServer 사용시 띄울 thread 의 갯수
@rtype: TServer, handler (Object)
@return: 생성된 서버 인스턴스, 서버에 연결되어 실제 함수를 처리하는 인스턴스
'''
handler_instance = handler()
processor_ = processor.Processor(handler_instance)
transport = TSocket.TServerSocket(port)
tfactory = TTransport.TBufferedTransportFactory()
# tfactory = TTransport.TFramedTransportFactory()
pfactory = TBinaryProtocol.TBinaryProtocolAcceleratedFactory()
# 서버를 어떻게 띄울 것인가?
if server_type == "TThreadedServer": # Thread per Connection
server = TServer.TThreadedServer(processor_, transport, tfactory, pfactory)
elif server_type == "TForkingServer": # Process per Connection
server = TServer.TForkingServer(processor_, transport, tfactory, pfactory)
elif server_type == "TThreadPoolServer": # Preloaded Thread with Pool
server = TServer.TThreadPoolServer(processor_, transport, tfactory, pfactory)
server.setNumThreads(num_threads)
else:
# No default
raise Exception("Unknown Server Type")
return server, handler_instance
# 实现类
class PythonServiceServer:
def get(self, id):
print socket.gethostbyname(socket.gethostname())
return "get==" + str(id)
def remove(self, id):
print socket.gethostbyname(socket.gethostname())
return id
def helloString(self, words):
print socket.gethostbyname(socket.gethostname())
return "word == " + str(words)
handler = PythonServiceServer()
# 注册实现类
processor = PythonService.Processor(handler)
transport = TSocket.TServerSocket('127.0.0.1', 30303)
tfactory = TTransport.TBufferedTransportFactory()
# pfactory = TBinaryProtocol.TBinaryProtocolFactory()
pfactory = TCompactProtocol.TCompactProtocolFactory()
# server = TServer.TSimpleServer( processor, transport, tfactory, pfactory )
server = TServer.TForkingServer(processor, transport, tfactory, pfactory)
print "Starting python server..."
server.serve()
print "done!"
def wrappee(*args, **kwargs):
logging.debug('in decorator before wrapee with flag ' + dec_name)
if "use_rpc" not in kwargs:
use_rpc = False
logging.warning("Defaulting to not use RPC for: " + dec_name)
else:
use_rpc = kwargs["use_rpc"]
if "server" not in kwargs:
use_server = False
logging.warning("Defaulting to not start as server for: " +
dec_name)
else:
use_server = kwargs["server"]
if use_rpc and use_server:
from thrift.protocol import TBinaryProtocol
from thrift.transport import TSocket
from thrift.transport import TTransport
from thrift.server import TServer
handler = original_clazz(*args, **kwargs)
processor = decorator_self._thrift_class.Processor(handler)
transport = TSocket.TServerSocket(port=decorator_self._port)
tfactory = TTransport.TBufferedTransportFactory()
pfactory = TBinaryProtocol.TBinaryProtocolFactory()
self.__inst = handler
if decorator_self._server_type == "THREADED":
server = TServer.TThreadedServer(processor, transport,
tfactory, pfactory)
elif decorator_self._server_type == "SIMPLE":
server = TServer.TSimpleServer(processor, transport,
tfactory, pfactory)
elif decorator_self._server_type == "FORK":
server = TServer.TForkingServer(processor, transport,
tfactory, pfactory)
elif decorator_self._server_type == "POOL":
server = TServer.TThreadPoolServer(processor, transport,
tfactory, pfactory)
server.setNumThreads(decorator_self._pool_size)
else:
server = None
logging.debug(decorator_self._server_type +
" server serving: " + dec_name)
server.serve()
logging.debug('Done: ' + dec_name)
elif use_rpc and not use_server:
from thrift.protocol import TBinaryProtocol
from thrift.transport import TSocket
from thrift.transport import TTransport
from thrift.server import TServer
# Make socket
decorator_self._transport = TSocket.TSocket(
host=dec_name, port=decorator_self._port)
# Buffering is critical. Raw sockets are very slow
num_retried = 0
while not decorator_self._transport.isOpen():
num_retried += 1
try:
decorator_self._transport.open()
decorator_self._transport = TTransport.TBufferedTransport(
self._transport)
except TTransport.TTransportException:
logging.debug("Failed to get connection, sleeping: " +
dec_name)
sleep(10)
logging.debug("Failed to get connection, retrying:" +
dec_name)
if num_retried > decorator_self._num_retries > 0:
raise ValueError(
"Maximum connection retries exceeded: ({0})".
format(dec_name))
# Wrap in a protocol
protocol = TBinaryProtocol.TBinaryProtocol(self._transport)
# Create a client to use the protocol encoder
client = decorator_self._thrift_class.Client(protocol)
logging.debug("Client (" + dec_name +
") connected to server: " +
str(self._transport.isOpen()))
return client
else:
logging.debug("Returning Singleton of class: " + dec_name)
return Singleton(original_clazz).Instance(*args, **kwargs)
