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)